artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/pass.rb

@@ -1,13 +1,15 @@
 class Pass < ActiveRecord::Base
   include Extendable
-  
+
   belongs_to  :pass_type
   belongs_to  :person
   belongs_to  :organization
   has_many    :tickets
 
   before_save :adjust_ends_at
-  
+  after_save { person.solr_index! if person }
+  after_destroy { person.solr_index! if person }
+
   EXPIRED_ERROR             = "Sorry! This pass has expired."
   OUT_OF_TICKETS            = "Sorry! There are no tickets remaning on this pass."
   OVER_EVENT_LIMIT          = "Sorry! This pass has already been redeemed for this event."
@@ -31,7 +33,7 @@ class Pass < ActiveRecord::Base
       pass.starts_at        = pass_type.starts_at
       pass.ends_at          = pass_type.ends_at
     end
-  end 
+  end
 
   def adjust_ends_at
     self.ends_at = self.ends_at.end_of_day unless self.ends_at.blank?
@@ -66,7 +68,7 @@ class Pass < ActiveRecord::Base
 
   def expired?
     ends_at < Time.now
-  end  
+  end
 
   def refundable?
     true
@@ -80,6 +82,10 @@ class Pass < ActiveRecord::Base
     false
   end
 
+  def convertable?
+    false
+  end
+
   def self.new_pass_code(size=8)
     # Avoid confusable characters like 1/L/I and 0/O
     charset = %w{ 2 3 4 6 7 9 A C D E F G H J K M N P Q R T V W X Y Z}
@@ -163,11 +169,11 @@ class Pass < ActiveRecord::Base
           Rails.logger.debug ("PASSES Now only [#{tickets_remaining_on_pass}] tickets remaining on this pass")
         else
           Rails.logger.debug ("PASSES rejecting ticket [#{ticket.id}]")
-          tickets_rejected << tickets 
+          tickets_rejected << tickets
         end
       end
 
-      if tickets_rejected.length > 0 
+      if tickets_rejected.length > 0
         str = ""
         if tickets_applied.length == 0
           str += "There are no tickets"
@@ -194,4 +200,4 @@ class Pass < ActiveRecord::Base
 
 
   end
-end
+end

data/app/models/pass_type.rb

@@ -2,11 +2,16 @@ class PassType < ActiveRecord::Base
   include Ext::Integrations::ServiceFee
   include OhNoes::Destroy
   extend ::ArtfullyOseHelper
-  
+
   belongs_to :organization
+  belongs_to :advanced_search_segment
   has_many :passes
 
-  attr_accessible :name, :description, :hide_fee, :thanks_copy, :email_copy, :sales_start_at, :sales_end_at, 
+  after_save { organization.people.each {|p| p.solr_index! } if organization && organization.people }
+  after_destroy { organization.people.each {|p| p.solr_index! } if organization && organization.people }
+  after_create :create_list_segment
+
+  attr_accessible :name, :description, :hide_fee, :thanks_copy, :email_copy, :sales_start_at, :sales_end_at,
                   :on_sale, :price, :tickets_allowed, :starts_at, :ends_at
 
   validates :name, :description, :price, :tickets_allowed, :starts_at, :ends_at, :presence => true
@@ -31,7 +36,7 @@ class PassType < ActiveRecord::Base
     sales_start_at
     sales_end_at
   end
-  
+
   def sold
     self.passes.select{ |p| p.person_id.present? }
   end
@@ -43,4 +48,12 @@ class PassType < ActiveRecord::Base
   def destroyable?
     self.passes.empty?
   end
-end
+
+  def create_list_segment
+    search  = AdvancedSearch.for_pass(self)
+    segment = AdvancedSearchSegment.create(:advanced_search_id => search.id, :organization_id => self.organization.id, :name => self.name)
+    self.advanced_search_segment = segment
+    self.save!
+  end
+  
+end

data/app/models/passes_report.rb

@@ -1,5 +1,5 @@
 class PassesReport
-  attr_accessor :pass_type, :header, :start_date, :end_date, :rows, :counts
+  attr_accessor :pass_type, :header, :start_date, :end_date, :rows, :counts, :organization
   attr_accessor :tickets_sold, :passes_sold, :total_tickets, :tickets_remaining, :original_price, :discounted
   extend ::ArtfullyOseHelper
 
@@ -11,6 +11,7 @@ class PassesReport
     self.pass_type = pass_type
     self.start_date = start_date
     self.end_date = end_date
+    self.organization = organization
 
     @orders = find_orders
 
@@ -30,7 +31,7 @@ class PassesReport
   end
 
   def calculate_total_tickets
-    @passes = Pass.owned
+    @passes = Pass.where(:organization_id => self.organization).owned
     if self.pass_type.present?
       @passes = @passes.where(:pass_type_id => self.pass_type.id)
     end    
@@ -48,13 +49,15 @@ class PassesReport
     end
 
     @items = @items.joins(:order)
+    @items = @items.where('orders.organization_id = ?', self.organization.id)
     @items = @items.where('orders.created_at > ?',self.start_date)  unless start_date.blank?
     @items = @items.where('orders.created_at < ?',self.end_date)    unless end_date.blank?
     @items.count
   end
 
   def find_orders
-    @orders = Order.includes(:person, :items => [:show => :event])
+    @orders = Order.where(:organization_id => self.organization)
+                   .includes(:person, :items => [:show => :event])
                    .joins(:items)
                    .joins("INNER join passes ON items.pass_id = passes.id")
                    .joins("INNER join pass_types ON passes.pass_type_id = pass_types.id")

data/app/models/payment.rb

@@ -6,6 +6,7 @@ class Payment
   include ActiveModel::Validations
   
   attr_accessor :amount, :user_agreement, :transaction_id
+  attr_accessor :benefactor
   
   #This is named customer as it analogizes the "customer" record on a remote payment
   # system (Braintree, for instance).  It is just a Person object.
@@ -58,8 +59,21 @@ class Payment
     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?
+
+    # 
+    # Storefront and sales console use a different hash to get the phone number
+    #
+    if params[:customer].present? && params[:customer][:phone].present? # storefront
+      self.customer.phones << Phone.new(:number => params.fetch(:customer, {}).fetch(:phone, ""))
+    elsif params[:customer].present? && params[:customer][:phones_attributes].present? # sales console
+      self.customer.phones << Phone.new(:number => params.fetch(:customer, {}).fetch(:phones_attributes,[]).first.fetch(:number,''))
+    elsif params[:person].present? && params[:person][:phones_attributes].first[:number].present? # box office
+      self.customer.phones << Phone.new(:number => params.fetch(:person, {}).fetch(:phones_attributes,[]).first.fetch(:number,''))
+    end   
+  end
+  
+  def payment_phone_number
+    self.customer.phones.first.try(:number)
   end
 
   def build_address_from(params)
@@ -107,10 +121,6 @@ class Payment
     false
   end
   
-  def payment_phone_number
-    nil
-  end
-  
   def reduce_amount_by(amount_in_cents)
     self.amount= self.amount - amount_in_cents
   end

data/app/models/payments/cash_payment.rb

@@ -4,6 +4,7 @@ class CashPayment < Payment
 
   def initialize(params = {})
     self.customer       ||= Person.new
+    self.benefactor = params[:benefactor]
     build_customer_from(params)
     build_address_from(params)
   end

data/app/models/payments/check_payment.rb

@@ -6,6 +6,7 @@ class CheckPayment < ::Payment
     @amount       = params[:amount]
     @check_number = params[:check].try(:[], :number)
     self.customer       ||= Person.new
+    self.benefactor = params[:benefactor]
     build_customer_from(params)
     build_address_from(params)
   end
@@ -14,11 +15,6 @@ class CheckPayment < ::Payment
     false
   end
 
-  def refund
-    self.errors.add(:base, "Check orders cannot be refunded.  Please return the tickets to inventory instead.")
-    false
-  end
-  
   def requires_settlement?
     false
   end

data/app/models/payments/comp_payment.rb

@@ -2,7 +2,6 @@
 # Comping from producer screens doesn't use this class
 class CompPayment < Payment
   payment_method :comp
-  attr_accessor :benefactor
   
   #benefactor is the user that is doing the comping (current_user)
   #person is the person record receiving the comp.  It must have the id set

data/app/models/payments/credit_card_payment.rb

@@ -13,13 +13,9 @@ class CreditCardPayment < ::Payment
   def per_item_processing_charge
     lambda { |item| item.realized_price * 0.035 }
   end
-  
-  def payment_phone_number
-    self.customer.phones.first.try(:number)
-  end
 
   def build(params)
-    [:amount, :user_agreement, :transaction_id].each do |field| 
+    [:amount, :user_agreement, :transaction_id, :benefactor].each do |field|
       self.instance_variable_set("@#{field.to_s}", params[field])
     end
     
@@ -143,8 +139,7 @@ class CreditCardPayment < ::Payment
       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")
+      Airbrake.notify(e, :parameters => {:error_message => "Failed to persist Gateway Transaction"})
     end
   end
 end

data/app/models/permission.rb

@@ -0,0 +1,28 @@
+class Permission
+  ORGANIZATION_ADMINISTRATOR = "Organization Administrator"
+  MANAGER = "Manager"
+  GENERAL_ASSOCIATE = "General Associate"
+  BOX_OFFICE_ASSOCIATE = "Box Office Associate"
+
+  def self.available_permissions
+    [ORGANIZATION_ADMINISTRATOR, MANAGER, GENERAL_ASSOCIATE, BOX_OFFICE_ASSOCIATE]
+  end
+
+  def self.available_permissions_for(organization)
+    organization.admin_limit_reached? ? Permission.available_permissions - [Permission::ORGANIZATION_ADMINISTRATOR] : self.available_permissions
+  end
+
+  def self.for(str)
+    return ORGANIZATION_ADMINISTRATOR  if str == "Organization Administrator"
+    return MANAGER                     if str == "Manager"
+    return GENERAL_ASSOCIATE           if str == "General Associate"
+    return BOX_OFFICE_ASSOCIATE        if str == "Box Office Associate"
+  end
+
+  def self.database_column_for(permission)
+    return "organization_administrator"  if (permission == ORGANIZATION_ADMINISTRATOR  || permission == "organization_administrator")
+    return "manager"                     if (permission == MANAGER                     || permission == "manager")
+    return "general_associate"           if (permission == GENERAL_ASSOCIATE           || permission == "general_associate")
+    return "box_office_associate"        if (permission == BOX_OFFICE_ASSOCIATE        || permission == "box_office_associate")
+  end
+end

data/app/models/person.rb

@@ -4,18 +4,23 @@ class Person < ActiveRecord::Base
   include Valuation::LifetimeValue
   include Valuation::LifetimeTicketValue
   include Valuation::LifetimeDonations
+  include Valuation::LifetimePledges
   include Valuation::LifetimeMemberships
 
+  COMPANY_TYPE = [['Business'], ['Foundation'], ['Government'], ['Nonprofit'], ['Other']]
+
   handle_asynchronously :calculate_lifetime_memberships
   handle_asynchronously :calculate_lifetime_donations
+  handle_asynchronously :calculate_lifetime_pledges
   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
+    :first_name, :middle_name, :last_name, :suffix, :birth_day, :birth_month, :birth_year,
+    :nickname, :listing_name, :maiden_name
+  attr_accessible :addresses_attributes, :phones_attributes, :relationships_attributes
 
   attr_accessible :subscribed_lists, :do_not_email, :do_not_call, :skip_sync_to_mailchimp
   attr_accessible :organization_id
@@ -30,12 +35,31 @@ class Person < ActiveRecord::Base
   has_many    :notes
   has_many    :orders
   has_many    :tickets, :foreign_key => 'buyer_id'
-  has_one     :address, :validate => false
+  has_many    :addresses, :order => 'is_primary DESC'
+  has_many    :soft_credits
+  has_many    :scheduled_pledge_payments
   has_one     :member
   has_many    :memberships, :through => :member
   has_many    :passes
 
-  has_many    :relationships, :foreign_key => :person_id, :class_name => 'Relationship'
+  has_many    :relationships, :foreign_key => :person_id, :class_name => 'Relationship', :dependent => :destroy
+
+  has_many :subscribed_lists
+  def address
+    if self.new_record?
+      (addresses.select { |address| address.is_primary}).try(:first)
+    else
+      addresses.where(:is_primary => true).try(:first)
+    end
+  end
+
+  def address=(value)
+    addresses << value unless value.nil?
+  end
+
+  def primary_address
+    addresses.select{ |a| a.is_primary? }.try(:first)
+  end
 
   def self.individuals
     where(:type => 'Individual')
@@ -63,15 +87,21 @@ class Person < ActiveRecord::Base
   end
 
   accepts_nested_attributes_for :relationships, :allow_destroy => true
-  accepts_nested_attributes_for :address, :allow_destroy => false
+  accepts_nested_attributes_for :addresses, :reject_if => :reject_address?, :allow_destroy => true
   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
-  before_validation :default_to_individual
+  before_validation :validate_addresses
+  before_validation :default_subtype
+
   after_update :sync_update_to_mailchimp, :except => :create
-  serialize :subscribed_lists, Array
+  after_update { ActionFeed.for(self.organization_id).rebuild_later }
+
+  serialize :old_subscribed_lists, Array
+  serialize :opted_out_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
@@ -81,6 +111,10 @@ class Person < ActiveRecord::Base
   validates :email, :uniqueness => { :scope => [:organization_id, :deleted_at], :message => " %{value} has already been taken." }, :allow_blank => true
   validate :birth_month_and_day
 
+  def reject_address?(a)
+    a[:address1].blank? && a[:address2].blank? && a[:city].blank? && a[:state].blank? && a[:zip].blank?
+  end
+
   def dupe_code
     "#{first_name} | #{last_name} | #{email}"
   end
@@ -117,7 +151,11 @@ class Person < ActiveRecord::Base
   # Tickets are a special case
   #
   def self.mergables
-    [:actions, :phones, :notes, :orders, :memberships, :passes]
+    [:actions, :phones, :notes, :orders, :soft_credits, :scheduled_pledge_payments, :passes, :subscribed_lists]
+  end
+
+  def self.loser_attributes_update_if_winner_not_present
+    ["company_name", "nickname", "listing_name", "maiden_name", "title", "salutation", "middle_name", "suffix", "twitter_handle", "facebook_url", "linked_in_url", "website", "birth_day", "birth_month", "birth_year", "email"]
   end
 
   def has_something?
@@ -141,33 +179,181 @@ class Person < ActiveRecord::Base
   end
 
   searchable do
-    text :first_name, :middle_name, :last_name, :email, :company_name, :title
+    text :first_name
+    text :last_name
+    text :email
+    text :company_name
+    text :title
+    text :nickname
+    text :listing_name
+    text :maiden_name
+
+    text :full_name do
+      self.to_s
+    end
 
     text :member_number do
       member.member_number unless member.nil?
     end
 
-    text :address do
-      address.to_s unless address.nil?
+    text :phone_numbers do
+      phones.map {|phone| phone.number.gsub(/[^a-zA-Z0-9]/, "") }.join(" ")
+    end
+    
+    text :clean_first_name do
+      first_name.gsub(/[^a-zA-Z0-9]/, '') unless first_name.nil?
+    end
+    
+    text :clean_middle_name do
+      middle_name.gsub(/[^a-zA-Z0-9]/, '') unless middle_name.nil?
     end
+    
+    text :clean_last_name do
+      last_name.gsub(/[^a-zA-Z0-9]/, '') unless last_name.nil?
+    end
+    
+    text :clean_full_name do
+      self.to_s.gsub(/[^a-zA-Z0-9]/, '')
+    end
+
+    # text :address do
+    #   address.to_s unless address.nil?
+    # end
 
     text :tags do
       taggings.map{ |tagging| tagging.tag.name }
     end
 
+    string :tag_list, multiple: true, stored: true do
+      tag_list.to_a
+    end
+
     text :notes do
       notes.map{ |note| note.text }.join(" ")
     end
 
-    string :first_name, :last_name, :email, :company_name, :title
+    boolean :deleted do
+      deleted_at.present?
+    end
+
+    integer :id, :stored => true
+    string :first_name, :stored => true
+    string :last_name, :stored => true
+    string :email, :stored => true do
+      self.email.blank? ? nil : self.email
+    end
+    string :company_name, :stored => true
+    string :title
+    string :type, :stored => true
+    string :subtype
+
     string :organization_id do
-      organization.id
+      organization_id
     end
 
     string :member_number do
       member.member_number unless member.nil?
     end
 
+    integer :birth_day
+    integer :birth_month
+    integer :birth_year
+    integer :lifetime_value
+
+    string :sort_name do
+      if type == "Individual"
+        "#{last_name} #{first_name}".downcase
+      elsif type == "Company"
+        company_name.try(:downcase)
+      end
+    end
+
+    text :city do
+      addresses.pluck(:city).join(' ')
+    end
+
+    string :state, multiple: true do
+      addresses.pluck(:state)
+    end
+
+    string :zip, multiple: true do
+      addresses.pluck(:zip)
+    end
+
+    string :country, multiple: true do
+      addresses.pluck(:country)
+    end
+
+    integer :discount_ids, multiple: true do
+      discount_codes = orders.map {|o| o.items.map(&:discount_id) }.flatten.compact.uniq
+      discount_codes.empty? ? nil : discount_codes
+    end
+
+    integer :event_ids, multiple: true do
+      event_ids = tickets.map {|t| t.show.event_id }.compact.uniq
+      event_ids.empty? ? nil : event_ids
+    end
+
+    date :donation_dates, multiple: true do
+      orders.map {|o| o.created_at if o.items.any? {|i| i.product_type == 'Donation'} }.compact
+    end
+
+    integer :relation_ids, multiple: true do
+      relationships.map(&:relation_id)
+    end
+
+    integer :membership_types, multiple: true do
+      memberships.any? ? memberships.map(&:membership_type_id) : nil
+    end
+
+    date :memberships_start_at, multiple: true do
+      memberships.any? ? memberships.map(&:starts_at) : nil
+    end
+
+    date :memberships_end_at, multiple: true do
+      memberships.any? ? memberships.map(&:ends_at) : nil
+    end
+
+    string :membership_status do
+      if member
+        if member.state == Member::CURRENT
+          'Current'
+        elsif member.state == Member::LAPSED
+          'Lapsed'
+        elsif member.state == Member::PAST
+          'Past'
+        else
+          'None'
+        end
+      else
+        'None'
+      end
+    end
+
+    string :mailchimp_list_ids, multiple: true do
+      list_ids = subscribed_lists.pluck(:list_id)
+      list_ids.empty? ? nil : list_ids
+    end
+
+    string :mailchimp_groups, multiple: true do
+      group_tuples = []
+      lists = subscribed_lists.includes(:groupings)
+      lists.each do |list|
+        list.groupings.each do |grouping|
+          group_tuples << "#{grouping.mailchimp_id}|#{grouping.group}"
+        end
+      end
+      group_tuples
+    end
+
+    integer :household_id
+
+    integer :pass_type_ids, multiple: true do
+      passes.map(&:pass_type_id)
+    end
+
+    integer :id, stored: true
+
   end
   include Ext::DelayedIndexing
 
@@ -178,22 +364,29 @@ class Person < ActiveRecord::Base
     middle_name
     last_name
     suffix
+    nickname
+    listing_name
+    maiden_name
     title
     type
     subtype
     company_name
-    address("Address 1") { |address| address && address.address1 }
-    address("Address 2") { |address| address && address.address2 }
-    address("City") { |address| address && address.city }
-    address("State") { |address| address && address.state }
-    address("Zip") { |address| address && address.zip }
-    address("Country") { |address| address && address.country }
-    phones("Phone1 type") { |phones| phones[0] && phones[0].kind }
-    phones("Phone1 number") { |phones| phones[0] && phones[0].number }
-    phones("Phone2 type") { |phones| phones[1] && phones[1].kind }
-    phones("Phone2 number") { |phones| phones[1] && phones[1].number }
-    phones("Phone3 type") { |phones| phones[2] && phones[2].kind }
-    phones("Phone3 number") { |phones| phones[2] && phones[2].number }
+
+    ('A'..'C').each_with_index do |letter, i|
+      addresses("Address#{letter} Type")        { |addresses| addresses[i] && addresses[i].kind }
+      addresses("Address#{letter} Address 1")   { |addresses| addresses[i] && addresses[i].address1 }
+      addresses("Address#{letter} Address 2")   { |addresses| addresses[i] && addresses[i].address2 }
+      addresses("Address#{letter} City")        { |addresses| addresses[i] && addresses[i].city }
+      addresses("Address#{letter} State")       { |addresses| addresses[i] && addresses[i].state }
+      addresses("Address#{letter} Zip")         { |addresses| addresses[i] && addresses[i].zip }
+      addresses("Address#{letter} Country")     { |addresses| addresses[i] && addresses[i].country }
+    end
+
+    (1..3).each do |i|
+      phones("Phone#{i} type")          { |phones| phones[i-1] && phones[i-1].kind }
+      phones("Phone#{i} number")        { |phones| phones[i-1] && phones[i-1].number }
+    end
+
     website
     twitter_handle
     facebook_url
@@ -216,51 +409,98 @@ class Person < ActiveRecord::Base
   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}]"
-    end
 
-    unless winner.type == loser.type
-      raise "Trying to merge two people [#{winner.id}] [#{loser.id}] with different types [#{winner.type}] [#{loser.type}]"
-    end
+    ActiveRecord::Base.transaction do
+      unless winner.organization == loser.organization
+        raise "Trying to merge two people [#{winner.id}] [#{loser.id}] from different organizations [#{winner.organization.id}] [#{winner.organization.id}]"
+      end
 
-    mergables.each do |mergable|
-      loser.send(mergable).each do |m|
-        m.person = winner
-        m.save!
+      unless winner.type == loser.type
+        raise "Trying to merge two people [#{winner.id}] [#{loser.id}] with different types [#{winner.type}] [#{loser.type}]"
       end
-    end
 
-    loser.tickets.each do |ticket|
-      ticket.update_column(:buyer_id, winner.id)
-    end
+      mergables.each do |mergable|
+        klass = Kernel.const_get(mergable.to_s.classify)
+        klass.where(:person_id => loser.id).update_all(:person_id => winner.id)
+      end
 
-    loser.tags.each do |t|
-      winner.tag_list << t.name unless winner.tag_list.include? t.name
-    end
+      loser.tickets.each do |ticket|
+        ticket.update_column(:buyer_id, winner.id)
+      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
+      loser.tags.each do |t|
+        winner.tag_list << t.name unless winner.tag_list.include? t.name
       end
+
+      loser.addresses.each do |address|
+        if winner.addresses.blank?
+          address.update_attributes(:person_id => winner.id)
+        elsif !winner.addresses.include?(address)
+          address.update_attributes(:person_id => winner.id, :is_primary => false)
+        end
+      end
+
+      # loser.relationships.each do |r|
+      #   r.copy_to(winner) unless r.involves?(winner)
+      # end
+      
+      loser_attributes_update_if_winner_not_present.each do |merge_attribute|
+        unless winner.send(merge_attribute).present?
+          if loser.send(merge_attribute).present?
+            value = loser.send(merge_attribute)
+            mergable_attribute = merge_attribute + '='
+            winner.send(mergable_attribute, value)
+          end
+        end
+      end
+
+      loser.relationships.each do |r|
+        r.copy_to(winner) unless r.involves?(winner)
+      end
+
+      loser.merge_member_for(winner)
+
+      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.map(&:list_id) - winner.subscribed_lists.map(&:list_id)
+      loser.destroy(with_prejudice: true)
+      winner.save!
+
+      mailchimp_kit = winner.organization.kits.mailchimp
+      MailchimpSyncJob.merged_person(mailchimp_kit, loser.email, winner.id, new_lists) if mailchimp_kit
+
+      return winner
     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
+  def merge_member_for(winner)
+    loser = self
+    winner_member = winner.member
+    loser_member  = loser.member
 
-    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!
-    loser.destroy(with_prejudice: true)
+    # If the loser has no member, we're done
+    return if loser_member.nil?
 
-    mailchimp_kit = winner.organization.kits.mailchimp
-    MailchimpSyncJob.merged_person(mailchimp_kit, loser.email, winner.id, new_lists) if mailchimp_kit
+    if winner_member.nil?
+      # If the winner has no member, copy the winner's details into the loser's member
+      # in doing this, loser memberships automatically point to the member so they
+      # do not need to be transferred
+      loser_member.email     = winner.email
+      loser_member.person_id = winner.id 
+      loser_member.save!
+    else 
+      # Update any Memberships from loser.member.id -> winner.member.id
+      Membership.where(:member_id => loser_member.id).update_all(:member_id => winner_member.id)
+    
+      # Cleanup the loser's membership
+      loser_member.destroy
+    end
 
-    return winner
   end
 
   #
@@ -272,7 +512,7 @@ class Person < ActiveRecord::Base
   # Addresses will be copied.
   # Phones will be ammended.
   # Tags will be ammended.
-  # orders and tickets will not be copied. 
+  # orders and tickets will not be copied.
   #
   def update_from_import(absorbee)
     ParsedRow.new([], []).person_attributes.keys.each do |key|
@@ -288,9 +528,12 @@ class Person < ActiveRecord::Base
       self.tag_list << t unless self.tag_list.include? t
     end
 
-    if self.address.blank?
-      self.address.try(:destroy)
-      self.address = absorbee.address
+    self.addresses.each do |address|
+      address.try(:destroy)
+    end
+
+    absorbee.addresses.each do |address|
+      self.addresses << address unless address.blank?
     end
 
     absorbee.phones.each do |phone|
@@ -300,11 +543,6 @@ class Person < ActiveRecord::Base
     self
   end
 
-  def self.find_by_email_and_organization(email, organization)
-    return nil if email.blank?
-    find(:first, :conditions => { :email => email, :organization_id => organization.id })
-  end
-
   def self.find_by_organization(organization)
     find_by_organization_id(organization.id)
   end
@@ -373,9 +611,8 @@ class Person < ActiveRecord::Base
       return person if person
     end
 
-    person = Person.find_by_email_and_organization(customer.email, organization)
-
-    if person.nil?
+    person = Person.where(:email => customer.email, :organization_id => organization.id).first
+    if person.blank?
       params = {
         :first_name      => customer.first_name,
         :last_name       => customer.last_name,
@@ -402,20 +639,17 @@ class Person < ActiveRecord::Base
     end
   end
 
-  # Needs a serious refactor
-  def update_address(new_address, time_zone, user = nil, updated_by = nil)
+  def update_address(new_address)
     unless new_address.nil?
       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)
-        ::Rails.logger.error "Could not update address from payment"
-        return false
+      new_address.is_primary = addresses.blank?
+      if addresses.blank? || !addresses.include?(new_address)
+        addresses << new_address
+        save
+        return true
       end
-      self.address = @address
-      save
     end
-    true
+    return false
   end
 
   def phone_missing?(phone_number)
@@ -452,7 +686,7 @@ class Person < ActiveRecord::Base
     note
   end
 
-  def create_subscribed_lists_notes!(user)
+  def update_and_note_subscriptions!(user, subscribed_list_ids, groupings, single_optin = false)
     if previous_changes["do_not_email"]
       new_note("#{user.email} changed do not email to #{do_not_email}",Time.now,user,organization.id)
     end
@@ -461,15 +695,24 @@ class Person < ActiveRecord::Base
       new_note("#{user.email} changed do not call to #{do_not_call}",Time.now,user,organization.id)
     end
 
-    if previous_changes["subscribed_lists"]
+    if mailchimp_kit && subscribed_list_ids
+      if do_not_email
+        subscribed_list_ids = []
+      end
+
+      new_lists = subscribed_list_ids - subscribed_lists.map(&:list_id)
+      old_lists = subscribed_lists.map(&:list_id) - subscribed_list_ids
+
       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])
+        if new_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])
+        elsif old_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
+
+      update_subscribed_lists(subscribed_list_ids, single_optin)
+      update_groupings(groupings)
     end
   end
 
@@ -487,9 +730,14 @@ class Person < ActiveRecord::Base
     end
   end
 
-  def default_to_individual
-    self.type ||= "Individual"
-    self.subtype ||= "Individual"
+  def default_subtype
+    if self.type == 'Individual'
+      self.subtype ||= 'Individual'
+    end
+
+    if self.type == 'Company'
+      self.subtype ||= 'Other'
+    end
   end
 
   def validate_naming_details
@@ -500,6 +748,19 @@ class Person < ActiveRecord::Base
     first_name.present? || last_name.present? || email.present? || company_name.present?
   end
 
+  def validate_addresses
+    errors.add(:base, "A primary address is empty") unless addresses.empty? || non_empty_primary_address_available?
+  end
+
+  def non_empty_primary_address_available?
+    addresses.each do |address|
+      if address.is_primary?
+        return true
+      end
+    end
+    return false
+  end
+
   def send_pass_summary_email(passes)
     PassMailer.pass_info_for(self, self.organization.email,passes).deliver
   end
@@ -507,13 +768,161 @@ class Person < ActiveRecord::Base
   def any_current_passes?
     passes.not_expired.any?
   end
+  
+  #
+  # encapsulate what happens to a person on people_controller#update
+  #
+  def update_person_attributes(params, updating_user)
+    success = self.update_attributes(params)
+
+    if success.eql?(true)
+      if self.member.present?
+        self.member.email = params['email'] if self.previous_changes.keys.include?('email')
+        self.member.save!
+      end
+      
+      self.relationships.where(:inverse_id => nil).map(&:ensure_inverse)
+    end
+    
+    success
+  end
+
+  def outstanding_pledges
+    orders.pledge.select { |o| !o.fully_paid? }
+  end
+
+  def scheduled_and_non_scheduled_pledges
+    not_received_scheduled_pledges = scheduled_pledge_payments.not_received.pluck(:order_id)
+    non_scheduled_pledges = []
+    outstanding_pledges.reject{|o| not_received_scheduled_pledges.include?(o.id)}.each_with_index do |o, index|
+      spp = ScheduledPledgePayment.new
+      spp.id = -(index + 1)
+      spp.order_id = o.id
+      spp.date = o.created_at.to_date
+      spp.amount = o.outstanding_amount.to_i / 100
+      non_scheduled_pledges <<  spp
+    end
+    non_scheduled_pledges + (scheduled_pledge_payments || [])
+  end
+
+  def subscribe_to_default_mailchimp_list!
+    return unless mailchimp_kit
+    subscribed_lists.create(:list_id => mailchimp_kit.default_list_id, :single_optin => true)
+  end
+
+  def opted_out_of_list?(list_id)
+    opted_out_lists.include?(list_id)
+  end
+
+  def subscribed_to_list?(list_id)
+    subscribed_list = subscribed_lists.where(:list_id => list_id).first
+    !subscribed_list.bounced? if subscribed_list
+  end
+
+  def in_group?(list_id, grouping_id, group_name)
+    subscribed_list = subscribed_lists.where(:list_id => list_id).first
+    subscribed_list.groupings.where(:mailchimp_id => grouping_id, :group => group_name).present? if subscribed_list
+  end
+
+  def confirmed_on_list?(list_id)
+    subscribed_list = subscribed_lists.where(:list_id => list_id).first
+    subscribed_list.confirmed? if subscribed_list
+  end
+
+  def unconfirmed_on_list?(list_id)
+    subscribed_list = subscribed_lists.where(:list_id => list_id).first
+    !subscribed_list.confirmed? if subscribed_list
+  end
+
+  def bounced_on_list?(list_id)
+    subscribed_list = subscribed_lists.where(:list_id => list_id).first
+    subscribed_list.bounced? if subscribed_list
+  end
+
+  def update_subscribed_lists(list_ids, single_optin)
+    # Remove lists that are unsubscribed
+    subscribed_lists.each do |subscribed_list|
+      next if list_ids.include?(subscribed_list.list_id)
+      subscribed_list.destroy
+    end
+
+    # subscribe to new lists
+    new_lists = list_ids - subscribed_lists.map(&:list_id)
+    new_lists.each do |list_id|
+      list = subscribed_lists.create(:list_id => list_id, :single_optin => single_optin)
+      if single_optin
+        list.update_attributes(:confirmed => true)
+      end
+    end
+  end
+
+  def update_groupings(groupings)
+    subscribed_lists.each do |subscribed_list|
+      subscribed_list.groupings.destroy_all
+    end
+
+    return unless groupings.present?
+
+    groupings.each do |list_id, groupings|
+      list = subscribed_lists.where(:list_id => list_id).first
+      attached_list = mailchimp_kit.attached_lists.detect { |list| list[:list_id] == list_id }
+      next unless list && attached_list
+      groupings.each do |grouping_id, groups|
+        grouping = attached_list.fetch(:groups, []).detect { |grouping| grouping["id"] == grouping_id.to_i }
+        next unless grouping
+        groups.each do |group|
+          list.groupings.create(:mailchimp_id => grouping_id, :name => grouping["name"], :group => group)
+        end
+      end
+    end
+
+    job = MailchimpSyncJob.new(mailchimp_kit, {
+      :type => "grouping_update",
+      :person_id => id,
+    })
+    Delayed::Job.enqueue(job, :queue => "mailchimp")
+  end
+
+  # Migrate object to a new STI class
+  # For example, individual.become_a!(Company) would convert the individual
+  # to a company and returns the new Company object with `type` already persisted.
+  def become_a!(klass)
+    klass = klass.constantize unless klass.is_a?(Class)
+    unless Person.descendants.include?(klass)
+      raise ArgumentError.new('That class is not a descendant of Person')
+    end
+    self.update_column(:type, klass.to_s)
+    self.solr_remove_from_index
+    klass.find(self.id)
+  end
 
   private
+    def check_list_bounce_status
+      return [] unless changes.has_key?("email")
+      bounced_lists = subscribed_lists.where(:bounced => true)
+      bounced_lists.each do |subscribed_list|
+        subscribed_list.bounced = false
+        subscribed_list.save
+      end
+      bounced_lists
+    end
+
     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?
+
+      updated_bounced_lists = check_list_bounce_status
+
+      job = MailchimpSyncJob.new(mailchimp_kit, {
+        :type => :person_update_to_mailchimp,
+        :person_id => id,
+        :person_changes => changes,
+        :bounced_list_ids => updated_bounced_lists.map(&:id),
+      })
+
+      if !mailchimp_kit.cancelled?
+        Delayed::Job.enqueue(job, :queue => "mailchimp")
+      end
     end
 
     def mailchimp_kit
@@ -521,18 +930,18 @@ class Person < ActiveRecord::Base
     end
 
     def mailchimp_changes?
-      ["first_name", "last_name", "email", "do_not_email", "subscribed_lists"].any? { |attr| changes.keys.include?(attr) }
+      ["first_name", "last_name", "email", "do_not_email"].any? { |attr| changes.keys.include?(attr) }
     end
 
     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