artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/actions/convert_action.rb

@@ -0,0 +1,19 @@
+class ConvertAction < Action
+
+  def editable?
+    subject.try(:editable?)
+  end
+
+  def action_type
+    "Give"
+  end
+
+  def verb
+    "converted"
+  end
+  
+  def sentence
+    " converted tickets into a donation"
+  end
+
+end

data/app/models/actions/do_action.rb

@@ -1,4 +1,6 @@
 class DoAction < Action
+  validates_presence_of :person_id
+
   def action_type
     "Do"
   end
@@ -14,4 +16,4 @@ class DoAction < Action
   def self.subtypes
     []
   end
-end
+end

data/app/models/actions/exchange_action.rb

@@ -1,6 +1,8 @@
 class ExchangeAction < GetAction
   include ImmutableAction
 
+  validates_presence_of :person_id
+
   def subtype
     "Exchange"
   end
@@ -12,4 +14,4 @@ class ExchangeAction < GetAction
   def verb
     ""
   end
-end
+end

data/app/models/actions/get_action.rb

@@ -1,6 +1,8 @@
 class GetAction < Action
   include ImmutableAction
   
+  validates_presence_of :person_id
+
   def subtype
     "Purchase"
   end
@@ -16,4 +18,4 @@ class GetAction < Action
   def self.subtypes
     []
   end
-end
+end

data/app/models/actions/give_action.rb

@@ -1,4 +1,6 @@
 class GiveAction < Action
+  validates_presence_of :person_id
+  
   def self.subtypes
     ["Monetary", "In-Kind"]
   end
@@ -20,7 +22,7 @@ class GiveAction < Action
   end
 
   def quip
-    "gave us (#{subtype.downcase})"
+    "gave us"
   end
 
   def set_params(params, person)
@@ -28,4 +30,8 @@ class GiveAction < Action
     self.dollar_amount = params[:dollar_amount]
     super(params, person)
   end
-end
+
+  def full_details
+    details
+  end
+end

data/app/models/actions/go_action.rb

@@ -2,6 +2,8 @@ class GoAction < Action
 
   has_many :tickets, :foreign_key => "validated_action_id"
 
+  validates_presence_of :person_id
+
   def show
     subject
   end
@@ -39,4 +41,4 @@ class GoAction < Action
   def self.subtypes
     []
   end
-end
+end

data/app/models/actions/hear_action.rb

@@ -1,4 +1,7 @@
 class HearAction < Action
+  validates_presence_of :person_id
+  MAILCHIMP_SENT = "Mailchimp (Sent)"
+
   def action_type
     "Hear"
   end
@@ -12,10 +15,21 @@ class HearAction < Action
   end
   
   def quip
-    "heard from us (via #{subtype.downcase})"
+    subtype.nil? ? "heard from us" : "heard from us (via #{subtype.downcase})"
   end
 
   def self.subtypes
     ["Email", "Phone", "Postal", "Meeting", "Twitter", "Facebook", "Blog", "Press"]
   end
+
+  def set_params(params, person)
+    super(params, person)
+    self.subject_id = params[:subject_id]
+    self.subject_type = params[:subject_type]
+  end
+
+  def can_wait?
+    (subtype == MAILCHIMP_SENT)
+  end
+
 end

data/app/models/actions/join_action.rb

@@ -1,4 +1,6 @@
 class JoinAction < Action
+  validates_presence_of :person_id
+
   def action_type
     "Join"
   end
@@ -6,4 +8,4 @@ class JoinAction < Action
   def self.subtypes
     []
   end
-end
+end

data/app/models/actions/mailchimp_hear_action.rb

@@ -0,0 +1,17 @@
+class MailchimpHearAction < HearAction
+  def action_type
+    if subtype =~ /open/i
+      "Open"
+    else
+      "Hear"
+    end
+  end
+
+  def quip
+    if subtype =~ /open/i
+      "opened"
+    else
+      "was sent"
+    end
+  end
+end

data/app/models/actions/pledge_action.rb

@@ -0,0 +1,19 @@
+class PledgeAction < Action
+
+  def editable?
+    subject.try(:editable?)
+  end
+
+  def action_type
+    "Pledge"
+  end
+
+  def verb
+    "pledged"
+  end
+  
+  def sentence
+    " pledged to your organization"
+  end
+
+end

data/app/models/actions/refund_action.rb

@@ -1,6 +1,8 @@
 class RefundAction < GetAction
   include ImmutableAction
 
+  validates_presence_of :person_id
+
   def subtype
     "Refund"
   end
@@ -12,4 +14,4 @@ class RefundAction < GetAction
   def verb
     ""
   end
-end
+end

data/app/models/actions/say_action.rb

@@ -1,4 +1,6 @@
 class SayAction < Action
+  validates_presence_of :person_id
+
   def action_type
     "Say"
   end
@@ -20,4 +22,4 @@ class SayAction < Action
   def self.subtypes
     ["Email", "Phone", "Postal", "Meeting", "Twitter", "Facebook", "Blog", "Press"]
   end
-end
+end

data/app/models/actions/system_action.rb

@@ -0,0 +1,17 @@
+class SystemAction < Action
+  def subtype
+    "System"
+  end
+
+  def action_type
+    "Hear"
+  end
+
+  def verb
+    ""
+  end
+
+  def sentence
+    details
+  end
+end

data/app/models/address.rb

@@ -1,10 +1,30 @@
 class Address < ActiveRecord::Base
 
-  attr_accessible :address1, :address2, :city, :state, :zip, :country, :person_id, :household_id
-
+  attr_accessor :member_update
+  attr_accessible :address1, :address2, :city, :state, :zip, :country, :person_id,
+                  :household_id, :kind, :is_primary, :member_update
   belongs_to :person
   belongs_to :household
 
+  after_save { person.solr_index! if person }
+  after_destroy { person.solr_index! if person }
+
+  searchable do
+    text :address1, :address2, :city, :state, :zip, :country
+    integer :person_id, stored: true
+    string :organization_id do
+      person.organization_id unless person.nil?
+    end
+  end
+  include Ext::DelayedIndexing
+
+  # after_save do |record|
+  #   Delayed::Job.enqueue(SuggestHouseholdsByAddressJob.new(record.id), :queue => :suggested_households)
+  # end
+
+  after_save :create_update_note, :if => :member_update
+  after_destroy :create_delete_note, :if => :member_update
+
   #
   # Needed because widget checkouts don't yet have a person_id
   #
@@ -12,6 +32,19 @@ class Address < ActiveRecord::Base
     !(address1.blank? || city.blank? || state.blank? || zip.blank?)
   end
 
+  def city_state
+    str = city
+
+    if city.present? && state.present?
+      str += ", "
+    end
+
+    if state.present?
+      str += state
+    end
+    str
+  end
+
   def address
     "#{address1} #{address2}"
   end
@@ -26,12 +59,15 @@ class Address < ActiveRecord::Base
   end
 
   def is_same_as(addr)
-    return address1.eql?(addr.address1) &&
+    return !addr.nil? &&
+           address1.eql?(addr.address1) &&
            address2.eql?(addr.address2) &&
            city.eql?(addr.city) &&
            state.eql?(addr.state) &&
            zip.eql?(addr.zip) &&
-           country.eql?(addr.country)
+           country.eql?(addr.country) &&
+           kind.eql?(addr.kind) &&
+           is_primary.eql?(addr.is_primary)
   end
 
   def self.from_payment(payment)
@@ -39,7 +75,7 @@ class Address < ActiveRecord::Base
   end
 
   def self.unhash(address)
-    (address.is_a? Hash) ? Address.new(address.except(:id, :created_at, :updated_at, :old_mongo_id))  : address
+    (address.is_a? Hash) ? Address.new(address.except(:id, :created_at, :updated_at, :_destroy)) : address
   end
 
   def self.find_or_create(pers_id)
@@ -47,33 +83,14 @@ class Address < ActiveRecord::Base
     where(:person_id => pers_id).first || Address.create(:person_id => pers_id)
   end
 
-  def update_with_note(person, user, address, time_zone, updated_by)
-    old_addr = to_s()
-
-    unless is_same_as(address)
-      ["address1", "address2", "city", "state", "zip", "country"].each do |field|
-        self.send("#{field}=", address.send(field))
-      end
-
-      if save
-        extra = updated_by.nil? ? "" : " from #{updated_by}"
-        text = "address updated#{extra}"
-        text = text + ", old address was: (#{old_addr})" unless old_addr.blank?
-        note = person.notes.create({
-          :occurred_at  => DateTime.now.in_time_zone(time_zone),
-          :text         => text
-        })
-        note.user = user
-      else
-        return false
-      end
-    end
-
-    true
-  end
-
   def ==(other)
-    address1 == other.address1 && address2 == other.address2  && city == other.city  && state == other.state  && zip == other.zip  && country == other.country
+    other.is_a?(Address) &&
+    address1 == other.address1 &&
+    address2 == other.address2  &&
+    city == other.city  &&
+    state == other.state  &&
+    zip == other.zip  &&
+    country == other.country
   end
 
   def values_hash
@@ -87,5 +104,33 @@ class Address < ActiveRecord::Base
     }
   end
 
+  def self.kinds
+    [ "Home", "Work", "Other" ]
+  end
+
+  private
 
+    def create_update_note
+      text = "Address #{old_addr.blank? ? 'added' : 'updated'} from member dashboard"
+      text = text + ", old address was: (#{old_addr})" unless old_addr.blank?
+      create_note(text)
+    end
+
+    def create_delete_note
+      text = "Address deleted from member dashboard"
+      text = text + ", it was: (#{old_addr})" unless old_addr.blank?
+      create_note(text)
+    end
+    
+    def create_note(text)
+      self.person.notes.create({
+         :organization_id => self.person.organization.id,
+         :occurred_at  => DateTime.now.in_time_zone(person.organization.time_zone),
+         :text         => text
+      })
+    end
+
+    def old_addr
+      "#{address1_was} #{address2_was} #{city_was} #{state_was} #{zip_was} #{country_was}"
+    end
 end

data/app/models/advanced_search.rb

@@ -0,0 +1,434 @@
+class AdvancedSearch < ActiveRecord::Base
+
+  belongs_to :organization
+  belongs_to :user
+  has_one :advanced_search_segment
+
+  validates_presence_of :organization_id
+  validate :keyword_presence, on: :create
+
+  attr_accessible :search_parameters, :organization_id
+
+  serialize :search_parameters, JSON
+
+  ANY_EVENT = '-1'
+  ANY_SHOW = '-1'
+  ANY_TICKET_TYPE = '-1'
+  ANY_MEMBERSHIP_TYPE = '-1'
+  ANY_PASS_TYPE = '-1'
+  MAX_SOLR_RESULTS = 10**9
+
+  def length
+    people.length
+  end
+
+  def people(page=1, per_page=20)
+    @people ||= perform_search(page, per_page).results
+  end
+
+  def all_people
+    @people ||= perform_search(1, MAX_SOLR_RESULTS).results
+  end
+
+  def people_hits(page=1, per_page=20)
+    @people ||= perform_search(page, per_page).hits
+  end
+
+  def people_ids(page=1, per_page=20)
+    @people_ids ||= perform_search(page, per_page).hits.map {|hit| hit.stored(:id) }
+  end
+
+  def tag(tag)
+    Delayed::Job.enqueue(TagJob.new(tag, people(1, MAX_SOLR_RESULTS)))
+  end
+
+  def attach_action(action)
+    Delayed::Job.enqueue(ActionJob.new(action, people(1, MAX_SOLR_RESULTS)))
+  end
+
+  def search_junction
+    return nil unless search_parameters
+
+    if search_parameters['conjunction'] == 'all_of'
+      :all_of
+    elsif search_parameters['conjunction'] == 'any_of'
+      :any_of
+    else
+      nil
+    end
+  end
+
+  def perform_search(page, per_page)
+    # Upgrade Note: This is written against Sunspot 1.3
+    # and greater_than and less_than are actually
+    # greater_than_or_equal and less_than_or_equal_to.
+    # These will need to be changed for Sunspot 2.0+
+
+    Person.search do
+      with(:organization_id, organization_id)
+      with(:deleted, false)
+
+      send(search_junction) do
+
+        matching_people = Proc.new { |search, preposition, field_name|
+
+          matching_people_ids = search.hits.map {|hit| hit.stored(field_name.to_sym) }.compact.uniq
+
+          if matching_people_ids.empty?
+            # We need negate this query in the main search since it didn't match
+            send(preposition, :id).equal_to(-1)
+          else
+            send(preposition, :id).any_of(matching_people_ids)
+          end
+
+        }
+
+        search_parameters.each do |filter_id, filter_settings|
+          preposition = if filter_settings['negation-filter'] == '0'
+            :with
+          elsif filter_settings['negation-filter'] == '1'
+            :without
+          end
+
+          case filter_settings['field_type']
+          when 'tagging'
+            send(preposition, :tag_list).equal_to(filter_settings['tag'])
+
+          when 'has_purchased_for'
+            # Solr search the tickets for this org, event, and date range first
+            ticket_search = Ticket.search do
+              with(:organization_id, organization_id)
+
+              if filter_settings['event_id'].present?
+                unless filter_settings['event_id'] == ANY_EVENT
+                  with(:event_id).equal_to(filter_settings['event_id'])
+                end
+              end
+
+              if filter_settings['show_id'].present?
+                unless filter_settings['show_id'] == ANY_SHOW
+                  with(:show_id).equal_to(filter_settings['show_id'])
+                end
+              end
+
+              if filter_settings['ticket_type_id'].present?
+                unless filter_settings['ticket_type_id'] == ANY_TICKET_TYPE
+                  with(:ticket_type_id).equal_to(filter_settings['ticket_type_id'])
+                end
+              end
+
+              paginate per_page: MAX_SOLR_RESULTS
+            end
+
+            matching_people.call(ticket_search, preposition, 'buyer_id')
+
+          when 'donated'
+            # Solr search the orders for this org and date range first
+            order_search = Order.search do
+              with(:organization_id, organization_id)
+
+              if filter_settings['min_donations_date'].present?
+                min_donations_date = Date.parse(filter_settings['min_donations_date'])
+                with(:created_at).greater_than(min_donations_date)
+              end
+
+              if filter_settings['max_donations_date'].present?
+                max_donations_date = Date.parse(filter_settings['max_donations_date'])
+                with(:created_at).less_than(max_donations_date)
+              end
+
+              paginate per_page: MAX_SOLR_RESULTS
+            end
+
+            if filter_settings['donation_lower_bound'].present?
+              lower_bound = filter_settings['donation_lower_bound'].to_i * 100
+            else
+              lower_bound = 1
+            end
+
+            if filter_settings['donation_upper_bound'].present?
+              upper_bound = filter_settings['donation_upper_bound'].to_i * 100
+            else
+              upper_bound = Float::INFINITY
+            end
+
+            # Sunspot 2+ supports grouping; for now we group by hand
+            people_id_donation_histogram = Hash.new(0)
+            order_search.hits.each do |hit|
+              people_id_donation_histogram[hit.stored(:person_id)] += hit.stored(:donation_amount)
+            end
+
+            # Reduce it down to Person IDs within the donation boundaries
+            matching_people_ids = people_id_donation_histogram.select do |person_id, donation_amount|
+              donation_amount.between?(lower_bound, upper_bound)
+            end.keys
+
+            # Search for the people
+            if matching_people_ids.empty?
+              send(preposition, :id).equal_to(-1) # Make this clause return false
+            else
+              send(preposition, :id).any_of(matching_people_ids)
+            end
+
+          when 'lifetime_value'
+            min_lifetime_value = filter_settings['lifetime_value_lower_bound'].to_i * 100
+            max_lifetime_value = filter_settings['lifetime_value_upper_bound'].to_i * 100
+
+            if filter_settings['lifetime_value_lower_bound'].present? && !filter_settings['lifetime_value_upper_bound'].present?
+              with(:lifetime_value).greater_than(min_lifetime_value)
+            end
+
+            if filter_settings['lifetime_value_upper_bound'].present? && !filter_settings['lifetime_value_lower_bound'].present?
+              with(:lifetime_value).less_than(max_lifetime_value)
+
+              # Set a default lower bound on non-negated upper bound searches
+              if preposition == :with
+                with(:lifetime_value).greater_than(1)
+              end
+            end
+
+            if filter_settings['lifetime_value_lower_bound'].present? && filter_settings['lifetime_value_upper_bound'].present?
+              with(:lifetime_value).between(min_lifetime_value..max_lifetime_value)
+            end
+
+          when 'discount_code'
+            if filter_settings['discount_code'] == Discount::ALL_DISCOUNTS_STRING
+              # Invert preposition here since we're not searching for presence of any discount_id
+              # but rather the presence of empty discount_ids.
+              if preposition == :with
+                without(:discount_ids, nil)
+              elsif preposition == :without
+                with(:discount_ids, nil)
+              end
+            else
+              send(preposition, :discount_ids).equal_to(filter_settings['discount_code'])
+            end
+
+          when 'location'
+            if filter_settings['zip'].present?
+              send(preposition, :zip).equal_to(filter_settings['zip'])
+            end
+
+            if filter_settings['location_state'].present?
+              send(preposition, :state).equal_to(filter_settings['location_state'])
+            end
+
+            if filter_settings['location_city'].present?
+              people_search = Person.search do
+                fulltext filter_settings['location_city'], :fields => :city
+
+                paginate per_page: MAX_SOLR_RESULTS
+              end
+
+              matching_people.call(people_search, preposition, 'id')
+            end
+
+            if filter_settings['location_country'].present?
+              send(preposition, :country).equal_to(filter_settings['location_country'])
+            end
+
+          when 'birthday'
+            if filter_settings['birth_year'].present?
+              send(preposition, :birth_year).equal_to(filter_settings['birth_year'])
+            end
+
+            if filter_settings['birth_month'].present?
+              send(preposition, :birth_month).equal_to(filter_settings['birth_month'])
+            end
+
+            if filter_settings['birth_day'].present?
+              send(preposition, :birth_day).equal_to(filter_settings['birth_day'])
+            end
+
+          when 'membership_started'
+            if filter_settings['min_membership_start_date'].present?
+              start_date = Date.parse(filter_settings['min_membership_start_date'])
+              with(:memberships_start_at).greater_than(start_date)
+            end
+
+            if filter_settings['max_membership_start_date'].present?
+              start_date = Date.parse(filter_settings['max_membership_start_date'])
+              with(:memberships_start_at).less_than(start_date)
+            end
+
+          when 'membership_ended'
+            if filter_settings['min_membership_end_date'].present?
+              end_date = Date.parse(filter_settings['min_membership_end_date'])
+              with(:memberships_end_at).greater_than(end_date)
+            end
+
+            if filter_settings['max_membership_end_date'].present?
+              end_date = Date.parse(filter_settings['max_membership_end_date'])
+              with(:memberships_end_at).less_than(end_date)
+            end
+
+          when 'membership_status'
+            send(preposition, :membership_status).equal_to(filter_settings['membership_status'])
+
+          when 'membership_type'
+            if filter_settings['membership_type_id'] == ANY_MEMBERSHIP_TYPE
+              if preposition == :without
+                with(:membership_types, nil)
+              else
+                without(:membership_types, nil)
+              end
+            else
+              send(preposition, :membership_types).equal_to(filter_settings['membership_type_id'].to_i)
+            end
+
+          when 'pass_type'
+            if filter_settings['pass_type_id'] == ANY_PASS_TYPE
+              if preposition == :without
+                with(:pass_type_ids, nil)
+              else
+                without(:pass_type_ids, nil)
+              end
+            else
+              send(preposition, :pass_type_ids).equal_to(filter_settings['pass_type_id'].to_i)
+            end
+
+          when 'relationships'
+            send(preposition, :relation_ids).equal_to(filter_settings['relation_id'])
+
+          when 'limit_results'
+            if filter_settings['limit'].present?
+              if %w(business foundation government nonprofit other).include?(filter_settings['limit'])
+                all_of do
+                  with(:type).equal_to('Company')
+                  with(:subtype).equal_to(filter_settings['limit'].titlecase)
+                end
+              elsif 'company' == filter_settings['limit']
+                with(:type).equal_to('Company')
+              else
+                with(:type).equal_to(filter_settings['limit'].titlecase)
+              end
+            end
+
+          when 'email'
+            if preposition == :without
+              with(:email, nil)
+            else
+              without(:email, nil)
+            end
+
+          when 'segment'
+            segment = AdvancedSearchSegment.find(filter_settings['advanced_search_segment_id'])
+            matching_people_ids = segment.advanced_search.people_hits.map {|hit| hit.stored(:id)}.compact.uniq
+
+            if matching_people_ids.empty?
+              send(preposition, :id).equal_to(-1)
+            else
+              send(preposition, :id).any_of(matching_people_ids)
+            end
+
+          when 'keyword'
+            if filter_settings['keyword_model'] == 'Note'
+              note_search = Note.search do
+                with(:organization_id, organization_id)
+                fulltext filter_settings['keyword_selection'], :fields => :text
+
+                paginate per_page: MAX_SOLR_RESULTS
+              end
+
+              matching_people.call(note_search, preposition, 'person_id')
+
+            elsif filter_settings['keyword_model'] == 'Action'
+              action_search = Action.search do
+                with(:organization_id, organization_id)
+                fulltext filter_settings['keyword_selection'], :fields => [:details, :verb]
+
+                paginate per_page: MAX_SOLR_RESULTS
+              end
+
+              matching_people.call(action_search, preposition, 'person_id')
+
+            elsif filter_settings['keyword_model'] == 'Address'
+              address_search = Address.search do
+                with(:organization_id, organization_id)
+                fulltext filter_settings['keyword_selection']
+
+                paginate per_page: MAX_SOLR_RESULTS
+              end
+
+              matching_people.call(address_search, preposition, 'person_id')
+
+            end
+
+          when 'orders'
+            order_search = Order.search do
+              with(:organization_id, organization_id)
+              if filter_settings['date_start'].present?
+                date_start = Date.parse(filter_settings['date_start'])
+                with(:created_at).greater_than(date_start)
+              end
+
+              if filter_settings['date_end'].present?
+                date_end = Date.parse(filter_settings['date_end'])
+                with(:created_at).less_than(date_end)
+              end
+
+              paginate per_page: MAX_SOLR_RESULTS
+            end
+
+            matching_people.call(order_search, preposition, 'person_id')
+
+          when 'action'
+            action_search = Action.search do
+              with(:organization_id, organization_id)
+              with(:type, filter_settings['action_type'])
+              if filter_settings['date_start'].present?
+                date_start = Date.parse(filter_settings['date_start'])
+                with(:created_at).greater_than(date_start)
+              end
+
+              if filter_settings['date_end'].present?
+                date_end = Date.parse(filter_settings['date_end'])
+                with(:created_at).less_than(date_end)
+              end
+
+              paginate per_page: MAX_SOLR_RESULTS
+            end
+
+            matching_people.call(action_search, preposition, 'person_id')
+
+          when 'mailchimp_list'
+            if filter_settings['mailchimp_list'].present?
+              send(preposition, :mailchimp_list_ids).equal_to(filter_settings['mailchimp_list'])
+            end
+
+          when 'mailchimp_group'
+            if filter_settings['mailchimp_group'].present?
+              send(preposition, :mailchimp_groups).equal_to(filter_settings['mailchimp_group'])
+            end
+
+          end
+        end
+      end
+
+      order_by(:sort_name, :asc)
+
+      paginate(page: page, per_page: per_page)
+    end
+  end
+
+  def self.for_membership_type(membership_type)
+    random_string = SecureRandom.hex[0..7]
+    AdvancedSearch.create(organization_id: membership_type.organization.id, search_parameters: {"conjunction" => "all_of", random_string => {"field_type" => "membership_type", "negation-filter" => "0", "membership_type_id" => membership_type.id}})
+  end
+
+  def self.for_pass(pass)
+    random_string = SecureRandom.hex[0..7]
+    AdvancedSearch.create(organization_id: pass.organization.id, search_parameters: {"conjunction" => "all_of", random_string => {"field_type" => "pass_type", "negation-filter" => "0", "pass_type_id" => pass.id}})
+  end
+
+  def empty_search?
+    search_parameters.size == 1
+  end
+
+  def keyword_presence
+    self.search_parameters.each_value do |value|
+      self.errors.add(:base, "Please specify a keyword") if value.is_a?(Hash) && value["keyword_selection"] == ""
+    end
+  end
+
+end