artfully_ose 1.1.0 → 1.2.0.alpha.1

data/app/models/phone.rb

@@ -2,14 +2,6 @@ class Phone < ActiveRecord::Base
   attr_accessible :kind, :number
   belongs_to :person
 
-  #This method is here solely to parse phones in the Athena migration
-  #There were in the form type:number
-  def self.from_athena(unparsed_phone)
-    Phone.new.tap do |phone|
-      phone.kind, phone.number = unparsed_phone.split(":")
-    end
-  end
-
   def self.kinds
     [ "Work", "Home", "Cell", "Fax", "Other" ]
   end

data/app/models/refund.rb

@@ -1,9 +1,8 @@
 class Refund
-  include Adjustments
-  attr_accessor :order, :refund_order, :items, :message
+  attr_accessor :order, :refund_order, :items, :message, :send_email_confirmation
 
   BRAINTREE_UNSETTLED_MESSAGE = "Cannot refund a transaction unless it is settled. (91506)"
-  FRIENDLY_UNSETTLED_MESSAGE = "The processor cannot refund that transaction yet. Please try again in a few hours."
+  FRIENDLY_UNSETTLED_MESSAGE = "Unfortunately we cannot refund credit card transactions until the day after they were processed. Please re-issue the refund tomorrow."
 
   def initialize(order, items)
     self.order = order
@@ -12,22 +11,33 @@ class Refund
 
   def submit(options = {})
     return_items_to_inventory = options[:and_return] || false
+    @send_email_confirmation = options[:send_email_confirmation] || false
 
-    items.each do |i|
-      unless i.refundable?
-        @message = "Those items have already been refunded."
-        return
+
+    ActiveRecord::Base.transaction do
+      items.each do |i|
+        unless i.refundable?
+          @message = "Those items have already been refunded."
+          return
+        end
       end
-    end
 
-    @payment = Payment.create(@order.payment_method)
-    @success = @payment.refund(refund_amount, order.transaction_id, options.merge({:service_fee => service_fee}))
-    @message = format_message(@payment)
-    
-    if @success
-      items.each { |i| i.return!(return_items_to_inventory) }
-      items.each(&:refund!)
-      create_refund_order(@payment.transaction_id)
+      @payment = Payment.create(@order.payment_method)
+      @success = @payment.refund(refund_amount, order.transaction_id, options.merge({:service_fee => service_fee}))
+      @message = format_message(@payment)
+      
+      if @success
+        #
+        # NOTE: That this will clean up the items, but the tickets will remain sold
+        #  if the show date has passed.
+        # because ticket.reset_price! is guarded with sold? and return_to_inventory
+        # is guarded with expired? (show date passed)
+        #
+        items.each { |i| i.return!(return_items_to_inventory) }
+        items.each(&:refund!)
+        create_refund_order(@payment.transaction_id)
+      end
+    #TODO: rollback refund as well
     end
   end
 
@@ -50,7 +60,7 @@ class Refund
   end
 
   def service_fee
-    (number_of_non_free_items(items) * service_fee_per_item(order.items))
+    items.collect(&:service_fee).sum
   end
 
   private
@@ -67,7 +77,7 @@ class Refund
       @refund_order.parent = order
       @refund_order.for_organization order.organization
       @refund_order.items = items.collect(&:to_refund)
-      @refund_order.service_fee = -1 * service_fee
+      @refund_order.skip_email = !send_email_confirmation
       @refund_order.save!
       @refund_order
     end

data/app/models/relation.rb

@@ -0,0 +1,27 @@
+class Relation < ActiveRecord::Base
+  attr_accessible :description, :inverse,
+    :person_can_be_individual,
+    :person_can_be_company,
+    :other_can_be_individual,
+    :other_can_be_company
+
+  has_many :relationships
+  belongs_to :inverse, :class_name => 'Relation', :dependent => :destroy
+
+  def self.for_individual
+    where(:person_can_be_individual => true)
+  end
+
+  def self.for_company
+    where(:person_can_be_company => true)
+  end
+
+  def self.for_type(type)
+    send("for_#{type.downcase}")
+  end
+
+  def indefinite_article
+    %w(a e i o u).include?(description[0].downcase) ? 'an' : 'a'
+  end
+
+end

data/app/models/relation_builder.rb

@@ -0,0 +1,32 @@
+class RelationBuilder
+  def self.build_single(description, pi, pc, oi, oc)
+    ActiveRecord::Base.transaction do
+      relation = Relation.create(:description => description,
+                                 :person_can_be_individual => pi,
+                                 :person_can_be_company => pc,
+                                 :other_can_be_individual => oi,
+                                 :other_can_be_company => oc)
+      relation.update_attribute(:inverse_id, relation.id)
+      relation
+    end
+  end
+
+  def self.build(description, inverse_description, pi, pc, oi, oc)
+    ActiveRecord::Base.transaction do
+      relation = Relation.create(:description => description,
+                                 :person_can_be_individual => pi,
+                                 :person_can_be_company => pc,
+                                 :other_can_be_individual => oi,
+                                 :other_can_be_company => oc)
+
+      inverse = relation.create_inverse(:description => inverse_description,
+                                        :person_can_be_individual => oi,
+                                        :person_can_be_company => oc,
+                                        :other_can_be_individual => pi,
+                                        :other_can_be_company => pc,
+                                        :inverse => relation)
+      relation.update_attribute(:inverse_id, inverse.id)
+      relation
+    end
+  end
+end

data/app/models/relationship.rb

@@ -0,0 +1,55 @@
+class Relationship < ActiveRecord::Base
+  attr_accessible :person, :relation, :other, :starred, :inverse, :relation_id, :other_id
+
+  belongs_to :person
+  belongs_to :other, :class_name => 'Person'
+  belongs_to :inverse, :class_name => 'Relationship', :dependent => :destroy, :foreign_key => :inverse_id
+  has_one :inverse_relationship, :class_name => 'Relationship', :dependent => :destroy, :foreign_key => :inverse_id
+  belongs_to :relation
+
+  validates_with RelationshipValidator
+
+  after_create :assign_company_name
+
+  def assign_company_name
+    return unless relation.description == 'employed by'
+    person.company_name = other.company_name unless person.company_name.present?
+    person.save!
+  end
+
+  def self.starred
+    where(:starred => true)
+  end
+
+  def self.unstarred
+    where(:starred => false)
+  end
+
+  def self.of_relation(relation)
+    where(:relation => {:description => relation})
+  end
+
+  def unstar!
+    Relationship.transaction do
+      self[:starred] = false
+      inverse[:starred] = false
+      save!
+      inverse.save!
+    end
+  end
+
+  def star!
+    Relationship.transaction do
+      self[:starred] = true
+      inverse[:starred] = true
+      save!
+      inverse.save!
+    end
+  end
+
+  def ensure_inverse
+    create_inverse(:relation => relation.inverse, :person => other, :other => person, :inverse => self)
+    save
+  end
+
+end

data/app/models/relationship_builder.rb

@@ -0,0 +1,12 @@
+class RelationshipBuilder
+  def self.build(person, other, relation)
+    ActiveRecord::Base.transaction do
+      relationship = person.relationships.create(:other => other, :relation => relation)
+      relationship.save!
+      inverse = other.relationships.create(:other => person, :relation => relation.inverse, :inverse => relationship)
+      inverse.save!
+      relationship.update_attribute(:inverse_id, inverse.id)
+      relationship
+    end
+  end
+end

data/app/models/relationship_validator.rb

@@ -0,0 +1,46 @@
+class RelationshipValidator < ActiveModel::Validator
+  def validate(record)
+    validate_uniqueness(record)
+    validate_relation(record)
+  end
+
+  private
+
+  def validate_relation(record)
+
+    relation = record.relation
+
+    msg = "of type '#{relation.description}' cannot exist between #{record.person.class.name} and #{record.other.class.name}"
+
+    if record.person.company? && !relation.person_can_be_company
+      record.errors[:relation] = msg
+    end
+
+    if record.person.individual? && !relation.person_can_be_individual
+      record.errors[:relation] = msg
+    end
+
+    if record.other.company? && !relation.other_can_be_company
+      record.errors[:relation] = msg
+    end
+
+    if record.other.individual? && !relation.other_can_be_individual
+      record.errors[:relation] = msg
+    end
+  end
+
+  def validate_uniqueness(record)
+    identical = Relationship.where(:person_id => record.person_id,
+                                   :relation_id => record.relation_id,
+                                   :other_id => record.other_id)
+    unless record.id.nil?
+      identical = identical.where('id != ?', record.id)
+    end
+
+    if identical.count > 0
+      record.errors[:base] << "#{record.person} is already in a '#{record.relation.description}' relationship with #{record.other}"
+    end
+  end
+
+end
+

data/app/models/relationships_kit.rb

@@ -0,0 +1,31 @@
+class RelationshipsKit < Kit
+
+  acts_as_kit :admin_only => true do
+    self.configurable = false
+
+    state_machine do
+      state :cancelled, :enter => :kit_cancelled
+    end
+
+    when_active do |organization|
+      organization.can :access, :relationships
+    end
+  end
+
+  def friendly_name
+    "Relationships"
+  end  
+
+  def pitch
+    "Track Relationships!"
+  end
+
+  def configured?
+    true
+  end
+
+  def configured!
+    settings[:membership_state] = "configured"
+    save
+  end
+end

data/app/models/rolling_membership_type.rb

@@ -0,0 +1,11 @@
+class RollingMembershipType < MembershipType
+  validates :duration, :presence => true
+
+  def starts_at
+    DateTime.now
+  end
+
+  def ends_at
+    self.duration.nil? ? nil : DateTime.now + (self.duration.send(self.period.downcase))
+  end
+end

data/app/models/sale.rb

@@ -1,23 +1,22 @@
 class Sale
   include ActiveModel::Validations
 
-  attr_accessor :sections, :quantities, :tickets, :cart, :message, :error, :sale_made
+  attr_accessor :ticket_types, :quantities, :tickets, :cart, :message, :error, :sale_made, :notes, :order
   attr_reader :buyer
 
   validate :has_tickets?
 
-  def initialize(show, sections, quantities = {})
+  def initialize(show, ticket_types, cart, quantities = {}, notes=nil)
     @show       = show
-    @sections   = sections
-    
+    @ticket_types   = ticket_types
+    @notes          = notes
+
     #When coming from a browser, all keys and values in @quantities are STRINGS
     @quantities = quantities
-    @cart       = BoxOffice::Cart.new
+    @cart       = cart
     @tickets     = []
-    
-    #This is irritating, it means you can't add tickets to a sale later
-    load_tickets      
-    cart.tickets << tickets
+
+    load_tickets
   end
 
   def sell(payment)
@@ -42,16 +41,21 @@ class Sale
   end
 
   def load_tickets
-    sections.each do |section|
-      tickets_available_in_section = Ticket.available({:section_id => section.id, :show_id => @show.id}, @quantities[section.id.to_s])
-      if tickets_available_in_section.length != @quantities[section.id.to_s].to_i
-        errors.add(:base, "There aren't enough tickets available in that section")
-      else
-        @tickets = @tickets + tickets_available_in_section
+    @quantities.keys.each do |ticket_type_id|
+      amount_requested = @quantities[ticket_type_id].to_i
+      if amount_requested > 0
+        ticket_type = TicketType.find(ticket_type_id)
+        tickets_available_in_ticket_type = ticket_type.available_tickets(amount_requested)
+        if tickets_available_in_ticket_type.length != amount_requested
+          errors.add(:base, "There aren't enough tickets available for that ticket type")
+        else
+          Ticket.lock(tickets_available_in_ticket_type, ticket_type, @cart)
+          @tickets = @tickets + tickets_available_in_ticket_type
+        end
       end
     end
   end
-  
+
   def has_tickets?
     unless non_zero_quantities?
       errors.add(:base, "Please select a number of tickets to purchase") and return false
@@ -63,22 +67,25 @@ class Sale
   private
 
     def comp_tickets(payment)
-      @comp = Comp.new(tickets.first.show, tickets, payment.customer, payment.benefactor)
+      @comp = Comp.new(tickets.first.show, tickets, [], payment.customer, payment.benefactor, notes)
       @comp.submit
       @buyer = @comp.recipient
+      @order = @comp.order
+      self.cart.approve!
       true
     end
-    
+
     def sell_tickets(payment)
-      checkout = BoxOffice::Checkout.new(cart, payment)
+      checkout = BoxOffice::Checkout.new(cart, payment, notes)
       begin
         success = checkout.finish
         @buyer = checkout.person
+        @order = checkout.order
         if !success
           if checkout.payment.errors.blank?
             errors.add(:base, "payment was not accepted")
           else
-            errors.add(:base, checkout.payment.errors.full_messages.to_sentence.downcase) 
+            errors.add(:base, checkout.payment.errors.full_messages.to_sentence.downcase)
           end
           return success
         end
@@ -91,4 +98,4 @@ class Sale
       end
       success
     end
-end
+end

data/app/models/sale_search.rb

@@ -24,7 +24,7 @@ class SaleSearch
   end
 
   def stop_with(stop)
-    stop.present? ? DateTime.parse(stop) + 1.day - 1.minute : default_stop
+    stop.present? ? Sundial.midnightish(@organization, stop) : default_stop
   end
 
   def default_start

data/app/models/search.rb

@@ -2,12 +2,26 @@ class Search < ActiveRecord::Base
 
   belongs_to :organization
   belongs_to :event
+  belongs_to :membership_type
+  belongs_to :pass_type
+  belongs_to :relation
+
   validates_presence_of :organization_id
 
-attr_accessible :zip, :state, :event_id, :tagging,
-                :min_lifetime_value, :max_lifetime_value,
-                :min_donations_amount, :max_donations_amount,
-                :min_donations_date, :max_donations_date, :discount_code
+  attr_accessible :zip, :state,
+                  :has_purchased_for, :event_id,
+                  :tagging, :person_subtype,
+                  :min_lifetime_value, :max_lifetime_value,
+                  :min_donations_amount, :max_donations_amount,
+                  :min_donations_date, :max_donations_date, :discount_code,
+                  :membership_status, :pass_type_id, :pass_type, :membership_type_id, :membership_type,
+                  :relation_id, :output_individuals, :output_households, :output_companies,
+                  :show_date_start, :show_date_end,
+                  :min_membership_start_date, :max_membership_start_date,
+                  :min_membership_end_date, :max_membership_end_date
+
+  ANY_EVENT = -1
+  ANY_MEMBERSHIP_TYPE = -1
 
   def length
     people.length
@@ -25,26 +39,44 @@ attr_accessible :zip, :state, :event_id, :tagging,
     Delayed::Job.enqueue(ActionJob.new(action, people))
   end
 
+  def event_name
+    event.try(:name) || Event::ANY_EVENT_TEXT
+  end
+
   def description
-    conditions = []
-    conditions << "Are tagged with #{tagging}." if tagging.present?
-    conditions << "Bought tickets for #{event.name}." if event_id.present?
+    c = ->(s){ "<li>#{s}</li>" }
+    conditions = ""
+
+    conditions << c.call("Are tagged with #{tagging}.") if tagging.present?
+    conditions << c.call("Have #{relation.indefinite_article} '#{relation.description}' relationship") if relation.present?
+
+    if event_id.present?
+      if has_purchased_for
+        conditions << c.call("Purchased tickets for #{event_name}.")
+      else
+        conditions << c.call("Have not purchased tickets for #{event_name}.")
+      end
+
+      conditions << c.call("For show dates after #{show_date_start.strftime('%D')}") if show_date_start.present?
+      conditions << c.call("For show dates through #{show_date_end.strftime('%D')}") if show_date_end.present?
+    end
+
     if zip.present? || state.present?
       locations = []
       locations << state if state.present?
       locations << "the zipcode of #{zip}" if zip.present?
-      conditions << "Are located within #{locations.to_sentence}."
+      conditions << c.call("Are located within #{locations.to_sentence}.")
     end
     if min_lifetime_value.present? && max_lifetime_value.present?
-      conditions << "Have a lifetime value between $#{min_lifetime_value} and $#{max_lifetime_value}."
+      conditions << c.call("Have a lifetime value between $#{min_lifetime_value} and $#{max_lifetime_value}.")
     elsif min_lifetime_value.present?
-      conditions << "Have a minimum lifetime value of $#{min_lifetime_value}."
+      conditions << c.call("Have a minimum lifetime value of $#{min_lifetime_value}.")
     elsif max_lifetime_value.present?
-      conditions << "Have a maximum lifetime value of $#{max_lifetime_value}."
+      conditions << c.call("Have a maximum lifetime value of $#{max_lifetime_value}.")
     end
 
     unless discount_code.blank?
-      conditions << ((discount_code == Discount::ALL_DISCOUNTS_STRING) ? "Used any discount code" : "Used discount code #{discount_code}.")
+      conditions << ((discount_code == Discount::ALL_DISCOUNTS_STRING) ? c.call("Used any discount code") : ("Used discount code #{discount_code}."))
     end
 
     unless [min_donations_amount, max_donations_amount, min_donations_date, max_donations_date].all?(&:blank?)
@@ -67,51 +99,308 @@ attr_accessible :zip, :state, :event_id, :tagging,
       else
         string << " overall."
       end
-      conditions << string
+      conditions << c.call(string)
+    end
+
+    categories = []
+
+    if output_companies
+      if person_subtype.present?
+        categories << person_subtype.downcase.pluralize
+      else
+        categories << "companies" if output_companies
+      end
+    end
+
+    if searching_membership?
+      if membership_status.present?
+        state_str = (membership_status == "None") ? "not" : membership_status.downcase
+        conditions << c.call("Are #{state_str} members")
+      end
+
+      if membership_type_id.present?
+        if any_membership_type?
+          conditions << c.call("Are members")
+        else
+          conditions << c.call("Are #{membership_type.name} members")
+        end
+      end
+
+
+      # Membership Start
+      if min_membership_start_date.present? && max_membership_start_date.present?
+        conditions << c.call("Have memberships starting from #{min_membership_start_date.strftime('%D')} through #{max_membership_start_date.strftime('%D')}.")
+      elsif min_membership_start_date.present?
+        conditions << c.call("Have memberships starting on or after #{min_membership_start_date.strftime('%D')}.")
+      elsif max_membership_start_date.present?
+        conditions << c.call("Have memberships starting on or before #{max_membership_start_date.strftime('%D')}.")
+      end
+      
+      # Membership End
+      if min_membership_end_date.present? && max_membership_end_date.present?
+        conditions << c.call("Have memberships ending from #{min_membership_end_date.strftime('%D')} through #{max_membership_end_date.strftime('%D')}.")
+      elsif min_membership_end_date.present?
+        conditions << c.call("Have memberships ending on or after #{min_membership_end_date.strftime('%D')}.")
+      elsif max_membership_end_date.present?
+        conditions << c.call("Have memberships ending on or before #{max_membership_end_date.strftime('%D')}.")
+      end
     end
 
+    if searching_passes?
+      conditions << c.call("Have a current #{pass_type.passerize}.")
+    end
+
+    categories << "individuals" if output_individuals
+    
+    if self.organization.can? :access,:relationships
+      categories << "households" if output_households
+    end
+
+    categories[-1] = "and #{categories[-1]}" if categories.length > 1
+
+    categories << "Anything " if categories.empty?
+
     if conditions.blank?
-      return "All people."
+      result = "All " << categories.join(", ") << "."
     else
-      return "People that: <ul>" + conditions.collect{|c| "<li>#{c}</li>"}.join + "</ul>"
+      result = categories.join(" ") << " that: " << "<ul>" << conditions << "</ul>"
+      result[0] = result[0].upcase
     end
+
+    result
+
+  end
+
+  def offset_show_date_start
+    return nil if self.show_date_start.blank?
+    @offset_show_date_start ||= self.show_date_start.to_datetime.change(:offset => offset(self.show_date_start))
+  end
+
+  def offset_show_date_end
+    return nil if self.show_date_end.blank?
+    @offset_show_date_end ||= self.show_date_end.to_datetime.end_of_day.change(:offset => offset(self.show_date_end))
+  end
+
+  def offset(datetime)
+    @offset ||= datetime.in_time_zone(ActiveSupport::TimeZone.create(self.organization.time_zone)).formatted_offset
   end
 
   private
 
-  def find_people
-    column_names = Person.column_names.collect {|cn| "people.#{cn}" }
-    column_names << "lower(people.last_name) AS ordered_last_names"
-
-    people = Person.where(:organization_id => organization_id)
-    people = people.where(:dummy => false)
-    people = people.order('ordered_last_names ASC')
-    people = people.tagged_with(tagging) unless tagging.blank?
-    people = people.joins(:address) unless zip.blank? && state.blank?
-    people = people.joins(:tickets => {:show => :event}).where("events.id" => event_id) unless event_id.blank?
-    people = people.where("addresses.zip" => zip.to_s) unless zip.blank?
-    people = people.where("addresses.state" => state) unless state.blank?
-    people = people.where("people.lifetime_value >= ?", min_lifetime_value * 100.0) unless min_lifetime_value.blank?
-    people = people.where("people.lifetime_value <= ?", max_lifetime_value * 100.0) unless max_lifetime_value.blank?
+    def find_people
+      column_names = Person.column_names.collect {|cn| "people.#{cn}" }
 
-    unless discount_code.blank?
-      people = people.joins(:orders => [:items => [:discount]])
-      people = (discount_code == Discount::ALL_DISCOUNTS_STRING) ? people.where("items.discount_id is not null") : people.where("discounts.code = ?", discount_code)
+      people = Person.where(:organization_id => organization_id)
+      people = people.where(:dummy => false)
+      people = people.order('ordered_last_names ASC')
+
+      people = people.tagged_with(tagging) unless tagging.blank?
+      people = people.joins(:address) unless zip.blank? && state.blank?
+
+      people = add_event_query(people, column_names)
+
+      people = people.where("addresses.zip" => zip.to_s) unless zip.blank?
+      people = people.where("addresses.state" => state) unless state.blank?
+      people = people.where("people.lifetime_value >= ?", min_lifetime_value * 100.0) unless min_lifetime_value.blank?
+      people = people.where("people.lifetime_value <= ?", max_lifetime_value * 100.0) unless max_lifetime_value.blank?
+
+      unless discount_code.blank?
+        people = people.joins(:orders => [:items => [:discount]])
+        people = (discount_code == Discount::ALL_DISCOUNTS_STRING) ? people.where("items.discount_id is not null") : people.where("discounts.code = ?", discount_code)
+      end
+
+      unless [min_donations_amount, max_donations_amount, min_donations_date, max_donations_date].all?(&:blank?)
+        people = people.joins(:orders => :items)
+        people = people.where("orders.created_at >= ?", min_donations_date) unless min_donations_date.blank?
+        people = people.where("orders.created_at <= ?", max_donations_date + 1.day) unless max_donations_date.blank?
+        people = people.where("items.product_type = 'Donation'")
+        people = people.group("people.id")
+        if min_donations_amount.blank?
+          people = people.having("SUM(items.price + items.nongift_amount) >= 1")
+        else
+          people = people.having("SUM(items.price + items.nongift_amount) >= ?", min_donations_amount * 100.0)
+        end
+        people = people.having("SUM(items.price + items.nongift_amount) <= ?", max_donations_amount * 100.0) unless max_donations_amount.blank?
+      end
+
+      ### MEMBERSHIP ##
+      if searching_membership?
+        people = people.joins('LEFT JOIN members ON members.person_id = people.id')
+        people = people.joins('LEFT JOIN memberships ON memberships.member_id = members.id ')
+        people = people.joins('LEFT JOIN membership_types ON membership_types.id = memberships.membership_type_id')
+      end
+
+      if membership_status.present?
+        people = people.merge(Member.current)       if membership_status == 'Current'
+        people = people.merge(Member.lapsed)        if membership_status == 'Lapsed'
+        people = people.merge(Member.past)          if membership_status == 'Past'
+        people = people.where('members.id IS NULL') if membership_status == 'None'
+      end
+
+      if membership_type_id.present?
+        people = if any_membership_type?
+          people.where('memberships.member_id IS NOT NULL')
+        else
+          people.where('membership_types.id = ?', membership_type_id)
+        end
+      end
+
+      # Membership Start
+      people = people.where('memberships.starts_at >= ?', min_membership_start_date) if min_membership_start_date.present?
+      people = people.where('memberships.starts_at <= ?', max_membership_start_date) if max_membership_start_date.present?
+
+      # Membership End
+      people = people.where('memberships.ends_at >= ?', min_membership_end_date) if min_membership_end_date.present?
+      people = people.where('memberships.ends_at <= ?', max_membership_end_date) if max_membership_end_date.present?
+
+      ### PASSES ###
+      if searching_passes?
+        people = add_passes_query(people)
+      end
+
+      people = people.companies if output_companies && !output_individuals
+      people = people.where("people.subtype" => person_subtype) if output_companies && person_subtype.present?
+
+      people = people.individuals if !output_companies && output_individuals
+
+      people = people.joins('left join households on people.household_id = households.id') if output_households
+
+      people = people.in_household if households_only?
+
+      if relation_id.present?
+        people = people.joins('left join relationships on people.id = relationships.person_id')
+        people = people.where(:relationships => {:relation_id => relation_id})
+      end
+      
+      column_names << "lower(people.last_name) AS ordered_last_names"
+      people.select(column_names).group("people.id")
     end
 
-    unless [min_donations_amount, max_donations_amount, min_donations_date, max_donations_date].all?(&:blank?)
-      people = people.joins(:orders => :items)
-      people = people.where("orders.created_at >= ?", min_donations_date) unless min_donations_date.blank?
-      people = people.where("orders.created_at <= ?", max_donations_date + 1.day) unless max_donations_date.blank?
-      people = people.where("items.product_type = 'Donation'")
-      people = people.group("people.id")
-      if min_donations_amount.blank?
-        people = people.having("SUM(items.price + items.nongift_amount) >= 1")
-      else
-        people = people.having("SUM(items.price + items.nongift_amount) >= ?", min_donations_amount * 100.0)
+    def households_only?
+      output_households && (!output_companies && !output_individuals)
+    end
+
+    def add_passes_query(people)
+      people = people.joins("LEFT JOIN #{Pass.table_name}     ON #{Pass.table_name}.person_id = #{Person.table_name}.id")
+      people = people.merge(Pass.not_expired)
+      people = people.where("#{Pass.table_name}.pass_type_id = ?", pass_type_id)
+      people
+    end
+
+    def add_event_query(people, column_names)
+      if any_event?
+        people = add_any_event_query(people, column_names)
+      elsif specific_event?
+        people = add_specific_event_query(people, column_names)
       end
-      people = people.having("SUM(items.price + items.nongift_amount) <= ?", max_donations_amount * 100.0) unless max_donations_amount.blank?
+      
+      people
+    end
+
+    def add_specific_event_query(people, column_names)
+      if has_purchased_for
+        people = people.joins("LEFT JOIN `tickets` ON `tickets`.`buyer_id` = `people`.`id` ")
+                       .joins("LEFT JOIN `shows` ON `shows`.`id` = `tickets`.`show_id` ") 
+                       .joins("LEFT JOIN `events` ON `events`.`id` = `shows`.`event_id`")
+        
+        people = people.where("events.id" => event_id)
+
+        if show_date_search?
+          people = people.where("shows.datetime >= ?", offset_show_date_start) unless show_date_start.blank?
+          people = people.where("shows.datetime <= ?", offset_show_date_end)   unless show_date_end.blank?
+        end
+
+      elsif !has_purchased_for
+        if show_date_search?
+          people_subquery = Ticket.joins(:show)
+                                  .where("shows.event_id = ?", event_id)
+                                  .where("tickets.buyer_id = people.id")
+
+          people_subquery = people_subquery.where("shows.datetime >= ?", offset_show_date_start) unless show_date_start.blank?
+          people_subquery = people_subquery.where("shows.datetime <= ?", offset_show_date_end)   unless show_date_end.blank?
+
+          people = people.where("NOT EXISTS (#{people_subquery.to_sql})")
+        else
+          #
+          # Had to use a correlated subquery here. Sorry.
+          # ActiveRecord 3.2 does not support NOT IN, so we have to do some manual work here.
+          # AR 4.0 has NOT IN
+          #
+          people_subquery = Person.select("people.id")
+                                 .joins("LEFT JOIN `tickets` ON `tickets`.`buyer_id` = `people`.`id` ")
+                                 .joins("LEFT JOIN `shows` ON `shows`.`id` = `tickets`.`show_id` ")
+                                 .joins("LEFT JOIN `events` ON `events`.`id` = `shows`.`event_id`")
+                                 .where("events.id" => event_id)
+          people = people.where("people.id not in (#{people_subquery.to_sql})")
+        end
+
+        people
+      end
+
+      people
+    end
+
+    def add_any_event_query(people, column_names)
+      people = people.joins("LEFT JOIN `tickets` ON `tickets`.`buyer_id` = `people`.`id` ")
+      
+      if has_purchased_for
+        column_names << "count(tickets.id) as ticket_count"
+        if show_date_search?
+          people = people.joins("LEFT JOIN `shows` ON `shows`.`id` = `tickets`.`show_id` ")
+          people = people.where("shows.datetime >= ?", offset_show_date_start) unless show_date_start.blank?
+          people = people.where("shows.datetime <= ?", offset_show_date_end)   unless show_date_end.blank?
+        end
+        people = people.having("ticket_count > 0")
+      elsif !has_purchased_for
+        if show_date_search?
+          people_subquery = Ticket.joins(:show)
+                                  .where("tickets.buyer_id = people.id")
+
+          people_subquery = people_subquery.where("shows.datetime >= ?", offset_show_date_start) unless show_date_start.blank?
+          people_subquery = people_subquery.where("shows.datetime <= ?", offset_show_date_end)   unless show_date_end.blank?
+                                  
+          people = people.where("NOT EXISTS (#{people_subquery.to_sql})")
+        else
+          column_names << "count(tickets.id) as ticket_count"
+          people = people.having("ticket_count = 0")
+        end
+      end
+
+      people   
+    end
+
+    def searching_for_event?
+      event_id.present?
+    end
+
+    def show_date_search?
+      show_date_start.present? || show_date_end.present?
+    end
+
+    def any_event?
+      self.event_id == ANY_EVENT
+    end
+
+    def specific_event?
+      self.event_id.present? && self.event_id > ANY_EVENT
+    end
+
+    def any_membership_type?
+      membership_type_id == ANY_MEMBERSHIP_TYPE
+    end
+
+    def searching_passes?
+      pass_type_id.present?
+    end
+
+    def searching_membership?
+      [
+        :membership_status,
+        :membership_type_id,
+        :min_membership_start_date,
+        :max_membership_start_date,
+        :min_membership_end_date,
+        :max_membership_end_date
+      ].any? { |s| send(s).present? }
     end
-    people.select(column_names).uniq
-  end
 end