artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/phone.rb

@@ -2,6 +2,9 @@ class Phone < ActiveRecord::Base
   attr_accessible :kind, :number
   belongs_to :person
 
+  after_save { person.solr_index! if person }
+  after_destroy { person.solr_index! if person }
+
   def self.kinds
     [ "Work", "Home", "Cell", "Fax", "Other" ]
   end

data/app/models/redis_manager.rb

@@ -0,0 +1,39 @@
+#
+# Manages our Redis connection
+# Eventually this class can be expanded to do some smart things
+#
+# Get a connection with `RedisManager.connection`
+#
+class RedisManager
+  cattr_accessor :redis
+
+  def self.connection
+    @@redis ||= Redis.new(:url => (ENV["REDISTOGO_URL"] || "redis://localhost:6379/"))
+  end
+
+  def self.burst_key(key)
+    "burst:#{key}"
+  end
+
+  #
+  # Useful for situations where a ton of things happen (like a bunch of new actions)
+  # and you want one thing to happen after that (like rebuilding the action feed)
+  #
+  # Situations like these are unsuitable for after_create callbacks
+  # because 1000 new actions will kick off 1000 rebuild jobs
+  #
+  # key: The unique identifier for this burst. "rebuild_feed"
+  # duration_in_seconds: seconds before clearing the key and allowing another burst
+  #
+  # Example:
+  #
+  # RedisManager.burst_job("rebuild_feed") { RebuildFeedJob.enqueue (...) }
+  #
+  def self.burst_job(key, duration_in_seconds = 10)
+    burst_val = self.connection.get(burst_key(key))
+    if !burst_val.present?
+      self.connection.set(burst_key(key), 1, {:ex => duration_in_seconds, :nx => true})
+      yield
+    end
+  end
+end

data/app/models/relationship.rb

@@ -1,15 +1,23 @@
 class Relationship < ActiveRecord::Base
-  attr_accessible :person, :relation, :other, :starred, :inverse, :relation_id, :other_id
+  include OhNoes::Destroy
+  attr_accessible :person, :person_id, :relation, :relation_id, :other, :other_id, :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 :inverse, :class_name => 'Relationship', :dependent => :delete, :foreign_key => :inverse_id
+  has_one :inverse_relationship, :class_name => 'Relationship', :foreign_key => :inverse_id
   belongs_to :relation
 
   validates_with RelationshipValidator
 
   after_create :assign_company_name
+  after_create :ensure_inverse_exists
+
+  after_save :ensure_sane_inverse
+
+  after_save do |record|
+    Delayed::Job.enqueue(SuggestHouseholdsBySpouseJob.new(record.id), :queue => :suggested_households) if(record.relation.description == 'spouse to')
+  end
 
   def assign_company_name
     return unless relation.description == 'employed by'
@@ -47,9 +55,28 @@ class Relationship < ActiveRecord::Base
     end
   end
 
-  def ensure_inverse
+  def copy_to(new_person)
+    Relationship.create(:person => new_person, :other => other, :relation => relation)
+  end
+
+  def involves?(person)
+    return [person_id, other_id].include?(person.id)
+  end
+
+  def is_inverse_of?(other)
+    person_id == other.other_id && other_id == other.person_id && relation_id == other.relation.inverse_id
+  end
+
+  private
+
+  def ensure_inverse_exists
+    return if inverse.present?
     create_inverse(:relation => relation.inverse, :person => other, :other => person, :inverse => self)
     save
   end
 
+  def ensure_sane_inverse
+    return if inverse.is_inverse_of?(self)
+    inverse.update_attributes(:person_id => other_id, :other_id => person_id, :relation_id => relation.inverse_id)
+  end
 end

data/app/models/relationship_builder.rb

@@ -3,9 +3,6 @@ class RelationshipBuilder
     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

data/app/models/rolling_membership_type.rb

@@ -6,6 +6,10 @@ class RollingMembershipType < MembershipType
   end
 
   def ends_at
-    self.duration.nil? ? nil : DateTime.now + (self.duration.send(self.period.downcase))
+    self.duration.nil? ? nil : DateTime.now + duration_in_seconds
+  end
+
+  def duration_in_seconds
+    self.duration.send(self.period.downcase)
   end
 end

data/app/models/s3_coordinator.rb

@@ -0,0 +1,21 @@
+class S3Coordinator
+  attr_reader :bucket
+
+  def initialize
+    @s3 = AWS::S3.new(
+          :access_key_id     => Rails.configuration.s3.access_key_id,
+          :secret_access_key => Rails.configuration.s3.secret_access_key
+        )
+    @bucket = @s3.buckets[Rails.configuration.s3.bucket]
+  end   
+
+  def create_file(filename, csv_string, content_type = 'text/csv')
+    bucket.objects.create("#{filename}", csv_string, { :acl => :private, :content_type => content_type} )
+  end
+
+  def download_link(filename, time)
+    object = bucket.objects[filename]
+    url    = object.url_for(:read, :expires => time)
+    url.to_s
+  end
+end

data/app/models/sale.rb

@@ -12,7 +12,7 @@ class Sale
     @notes          = notes
 
     #When coming from a browser, all keys and values in @quantities are STRINGS
-    @quantities = quantities
+    @quantities = (quantities || {})
     @cart       = cart
     @tickets     = []
 
@@ -23,6 +23,7 @@ class Sale
     if valid?
       case payment
       when CompPayment
+        puts payment.customer.inspect
         @sale_made = comp_tickets(payment)
       else
         @sale_made = sell_tickets(payment)
@@ -41,6 +42,8 @@ class Sale
   end
 
   def load_tickets
+    return if @quantities.nil?
+
     @quantities.keys.each do |ticket_type_id|
       amount_requested = @quantities[ticket_type_id].to_i
       if amount_requested > 0
@@ -58,7 +61,7 @@ class Sale
 
   def has_tickets?
     unless non_zero_quantities?
-      errors.add(:base, "Please select a number of tickets to purchase") and return false
+      errors.add(:base, "Please select a number of tickets to purchase. If you're trying to process a single donaiton, please use the Sales Console") and return false
     end
     errors.add(:base, "no tickets were added") unless @tickets.size > 0
     @tickets.size > 0
@@ -67,7 +70,7 @@ class Sale
   private
 
     def comp_tickets(payment)
-      @comp = Comp.new(tickets.first.show, tickets, [], payment.customer, payment.benefactor, notes)
+      @comp = Comp.new(tickets, [], [], payment.customer, payment.benefactor, notes)
       @comp.submit
       @buyer = @comp.recipient
       @order = @comp.order
@@ -78,7 +81,7 @@ class Sale
     def sell_tickets(payment)
       checkout = BoxOffice::Checkout.new(cart, payment, notes)
       begin
-        success = checkout.finish
+        success = checkout.process
         @buyer = checkout.person
         @order = checkout.order
         if !success

data/app/models/scheduled_pledge_payment.rb

@@ -0,0 +1,69 @@
+class ScheduledPledgePayment < ActiveRecord::Base
+  attr_accessible :amount_received
+  belongs_to :person
+  belongs_to :organization
+  belongs_to :donation
+  belongs_to :order
+
+  scope :received, lambda { where('amount_received IS NOT NULL') }
+  scope :not_received, lambda { where('amount_received IS NULL') }
+
+  def self.update_pledge_payments(db_pledge_payments, curr_pledge_payments, organization_id, order_id, donation_id, person_id)
+    new_pledge_payments = db_pledge_payments.empty? ? curr_pledge_payments : []
+    deleted_pledge_payment_ids = Set.new
+    updated_pledge_payments = Set.new
+
+    db_pledge_payments.each do |db_pp|
+      deleted_pledge_payment_ids << db_pp.id if db_pp.id > 0 #mark temporary all as deleted
+      curr_pledge_payments.each do |curr_pp|
+        deleted_pledge_payment_ids.delete(db_pp.id) if curr_pp.id.to_i == db_pp.id.to_i #remove from deleted list presented only
+        if curr_pp.id.to_i == db_pp.id.to_i
+          db_pp.amount = curr_pp.amount
+          db_pp.date = curr_pp.date
+          updated_pledge_payments << db_pp
+        elsif curr_pp.id.to_i < 0
+          new_pledge_payments << curr_pp #all with negative id are new
+        end
+      end
+    end
+
+    save_all(new_pledge_payments.uniq, organization_id, order_id, donation_id, person_id)
+
+    updated_pledge_payments.each do |pp| #update existing records
+      pp.save!
+    end
+
+    ScheduledPledgePayment.where(:id => deleted_pledge_payment_ids.to_a()).destroy_all # destroy deleted records
+  end
+
+  def self.save_all(pledge_payments, organization_id, order_id, donation_id, person_id)
+    pledge_payments.each do |pp|
+      next if !pp.amount && !pp.date
+      pp.id = nil if pp.id.to_i <= 0
+      pp.organization_id = organization_id
+      pp.order_id        = order_id
+      pp.donation_id     = donation_id
+      pp.person_id       = person_id
+      pp.save!
+    end
+  end
+
+  def self.build_pledge_payments(pledge_payments_hash = nil)
+    pledge_payments = []
+    pledge_payments_hash.each do |id, pp|
+      pledge_payment = ScheduledPledgePayment.new
+      pledge_payment.id = id
+      pledge_payment.date = pp[:date]
+      pledge_payment.amount = pp[:amount]
+      pledge_payments << pledge_payment
+    end
+    pledge_payments
+  end
+
+  def self.default_pledge_payment
+    pledge_payment = ScheduledPledgePayment.new
+    pledge_payment.id = -Time.now.to_i
+    pledge_payment
+  end
+
+end

data/app/models/search.rb

@@ -5,6 +5,8 @@ class Search < ActiveRecord::Base
   belongs_to :membership_type
   belongs_to :pass_type
   belongs_to :relation
+  belongs_to :campaign
+  belongs_to :appeal
 
   validates_presence_of :organization_id
 
@@ -12,13 +14,25 @@ class Search < ActiveRecord::Base
                   :has_purchased_for, :event_id,
                   :tagging, :person_subtype,
                   :min_lifetime_value, :max_lifetime_value,
+                  :gift_type, :campaign_id, :appeal_id,
                   :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
+                  :min_membership_end_date, :max_membership_end_date,
+
+                  :mailchimp_lists, :not_mailchimp_lists,
+                  :groupings, :not_groupings,
+                  :birth_day, :birth_month, :birth_year,
+                  :has_donated
+
+
+  serialize :mailchimp_lists, Array
+  serialize :not_mailchimp_lists, Array
+  serialize :groupings, Hash
+  serialize :not_groupings, Hash
 
   ANY_EVENT = -1
   ANY_MEMBERSHIP_TYPE = -1
@@ -78,16 +92,24 @@ class Search < ActiveRecord::Base
     unless discount_code.blank?
       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?)
+    unless ([gift_type, campaign_id, appeal_id, min_donations_amount, max_donations_amount, min_donations_date, max_donations_date].all?(&:blank?) && (has_donated == true))
+      donation_type = gift_type.present? ?  (Donation::GIFT_TYPES[gift_type]).downcase.pluralize : "gifts"
       if min_donations_amount.present? && max_donations_amount.present?
-        string = "Made between $#{min_donations_amount} and $#{max_donations_amount} in donations"
+        string = "Made between $#{min_donations_amount} and $#{max_donations_amount} in #{donation_type}"
       elsif min_donations_amount.present?
-        string = "Made a total minimum of $#{min_donations_amount} in donations"
+        string = "Made a total minimum of $#{min_donations_amount} in #{donation_type}"
       elsif max_donations_amount.present?
-        string = "Made no more than $#{max_donations_amount} in total donations"
+        string = "Made no more than $#{max_donations_amount} in total #{donation_type}"
+      elsif (has_donated == false)
+        string = "Have not donated"
       else
-        string = "Made any donations"
+        string = "Made any #{donation_type}"
+      end
+
+      if campaign_id.present? && appeal_id.present?
+        string << " for appeal #{appeal.name}"
+      elsif campaign_id.present?
+        string << " for campaign #{campaign.name}"
       end
 
       if min_donations_date.present? && max_donations_date.present?
@@ -149,6 +171,68 @@ class Search < ActiveRecord::Base
     if searching_passes?
       conditions << c.call("Have a current #{pass_type.passerize}.")
     end
+    
+    if searching_birthday?
+      if birth_day.blank?
+        conditions << c.call("Have a birthday in: " + output_birthday(birth_month, birth_day, birth_year))
+      else
+        conditions << c.call("Have a birthday on: " + output_birthday(birth_month, birth_day, birth_year))
+      end
+    end
+
+    if mailchimp_lists.present?
+      mailchimp_kit = organization.kits.mailchimp
+
+      mailchimp_lists.each do |list_id|
+        list = mailchimp_kit.attached_lists.detect { |list| list[:list_id] == list_id }
+        conditions << c.call("Are subscribed to #{list[:list_name]}") if list
+      end
+    end
+
+    if not_mailchimp_lists.present?
+      mailchimp_kit = organization.kits.mailchimp
+
+      not_mailchimp_lists.each do |list_id|
+        list = mailchimp_kit.attached_lists.detect { |list| list[:list_id] == list_id }
+        conditions << c.call("Are not subscribed to #{list[:list_name]}") if list
+      end
+    end
+
+    if groupings.present?
+      mailchimp_kit = organization.kits.mailchimp
+
+      groupings.each do |grouping_id, groups|
+        list = mailchimp_kit.attached_lists.detect do |list|
+          list.fetch(:groups, []).any? do |grouping|
+            grouping["id"] == grouping_id.to_i
+          end
+        end
+        next unless list
+        grouping = list.fetch(:groups, []).detect do |grouping|
+          grouping["id"] == grouping_id.to_i
+        end
+        next unless grouping
+        conditions << c.call("Are subscribed to the groups #{groups.join(", ")} in the grouping #{grouping["name"]} for list #{list[:list_name]}")
+      end
+    end
+
+    if not_groupings.present?
+      mailchimp_kit = organization.kits.mailchimp
+
+      not_groupings.each do |grouping_id, groups|
+        list = mailchimp_kit.attached_lists.detect do |list|
+          list.fetch(:groups, []).any? do |grouping|
+            grouping["id"] == grouping_id.to_i
+          end
+        end
+        next unless list
+        grouping = list.fetch(:groups, []).detect do |grouping|
+          grouping["id"] == grouping_id.to_i
+        end
+        next unless grouping
+        conditions << c.call("Are not subscribed to the groups #{groups.join(", ")} in the grouping #{grouping["name"]} for list #{list[:list_name]}")
+      end
+    end
 
     categories << "individuals" if output_individuals
     
@@ -185,17 +269,62 @@ class Search < ActiveRecord::Base
     @offset ||= datetime.in_time_zone(ActiveSupport::TimeZone.create(self.organization.time_zone)).formatted_offset
   end
 
+  def include_group?(grouping_id, group)
+    return false unless groupings
+    groupings.fetch(grouping_id.to_s, []).include?(group)
+  end
+
+  def not_include_group?(grouping_id, group)
+    return false unless not_groupings
+    not_groupings.fetch(grouping_id.to_s, []).include?(group)
+  end
+
+  def include_mailchimp_list?(list_id)
+    return false unless mailchimp_lists
+    mailchimp_lists.include?(list_id)
+  end
+
+  def include_not_mailchimp_list?(list_id)
+    return false unless not_mailchimp_lists
+    not_mailchimp_lists.include?(list_id)
+  end
+
   private
+  
+    def birth_year?
+      birth_year.present?
+    end
+    
+    def birth_month_and_day?
+      birth_month.present? && birth_day.present?
+    end
+    
+    def birth_month?
+      birth_month.present?
+    end
 
     def find_people
       column_names = Person.column_names.collect {|cn| "people.#{cn}" }
 
       people = Person.where(:organization_id => organization_id)
       people = people.where(:dummy => false)
+      
+      if birth_year?
+        people = people.where("birth_year = ?", birth_year)
+      end
+      
+      if birth_month_and_day?
+        people = people.where("birth_month = ? AND birth_day = ?", birth_month, birth_day)
+      end
+      
+      if birth_month?
+        people = people.where("birth_month = ?", birth_month) unless birth_month_and_day?
+      end
+      
       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(:addresses) unless zip.blank? && state.blank?
 
       people = add_event_query(people, column_names)
 
@@ -209,31 +338,52 @@ class Search < ActiveRecord::Base
         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)
+      if(has_donated == false)
+          
+          #this will return all people w/ no donations, and people who have not donated within a designated time window
+          people_subquery_donations = Item.joins("INNER JOIN orders ON orders.id = items.order_id")
+                                          .where("orders.person_id = people.id AND items.product_type = 'Donation'")
+          people_subquery_donations = people_subquery_donations.where('orders.created_at > ?', min_donations_date) if min_donations_date.present?
+          people_subquery_donations = people_subquery_donations.where('orders.created_at < ?', max_donations_date + 1.day) if max_donations_date.present?
+          people = people.where("NOT EXISTS (#{people_subquery_donations.to_sql})")
+       
+      else
+        unless [gift_type, campaign_id, appeal_id, min_donations_amount, max_donations_amount, min_donations_date, max_donations_date].all?(&:blank?)
+          people = people.joins(:orders => [:items, :donation])
+          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.where('donations.campaign_id = ?', campaign_id) unless campaign_id.blank?
+          people = people.where('donations.appeal_id = ?', appeal_id) unless appeal_id.blank?
+          if gift_type == 'pledge'
+            people = people.where('donations.pledge=?', true)
+          elsif gift_type == 'donation'
+            people = people.where('donations.pledge=? AND orders.parent_id IS NULL', false)
+          elsif gift_type == 'pledge_payment'
+            people = people.where('donations.pledge=? AND orders.parent_id IS NOT NULL', false)
+          end
+
+          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
-        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 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.joins('LEFT JOIN memberships ON memberships.member_id = members.id').merge(Membership.current) if membership_status == 'Current'
+        people = people.joins('LEFT JOIN memberships ON memberships.member_id = members.id').merge(Membership.lapsed)  if membership_status == 'Lapsed'
+        people = people.joins('LEFT JOIN memberships ON memberships.member_id = members.id').merge(Membership.past)    if membership_status == 'Past'
         people = people.where('members.id IS NULL') if membership_status == 'None'
       end
 
@@ -271,7 +421,53 @@ class Search < ActiveRecord::Base
         people = people.joins('left join relationships on people.id = relationships.person_id')
         people = people.where(:relationships => {:relation_id => relation_id})
       end
-      
+
+      if mailchimp_lists.present?
+        people = people.joins(:subscribed_lists).
+          where(:subscribed_lists => { :list_id => mailchimp_lists })
+      end
+
+      if not_mailchimp_lists.present?
+        list_sql = not_mailchimp_lists.map do |list_id|
+          "list_id = ?"
+        end.join(" OR ")
+        people = people.where("not exists (select 1 from subscribed_lists where subscribed_lists.person_id = people.id and (#{list_sql}))", *not_mailchimp_lists)
+      end
+
+      if groupings.present?
+        people = people.joins(:subscribed_lists => [:groupings])
+
+        sql = []
+        sql_args = []
+        groupings.each do |grouping_id, groups|
+          group_sql = groups.map do |group|
+            "list_groupings.`group` = ?"
+          end.join(" OR ")
+          sql << "(list_groupings.mailchimp_id = ? AND (#{group_sql}))"
+          sql_args.concat([grouping_id, *groups])
+        end
+
+        people = people.where(sql.join(" OR "), *sql_args)
+      end
+
+      if not_groupings.present?
+        subquery = ListGrouping.joins(:subscribed_list).
+          where("subscribed_lists.person_id = people.id")
+
+        sql = []
+        sql_args = []
+        not_groupings.each do |grouping_id, groups|
+          group_sql = groups.map do |group|
+            "list_groupings.`group` = ?"
+          end.join(" OR ")
+          sql << "(list_groupings.mailchimp_id = ? AND (#{group_sql}))"
+          sql_args.concat([grouping_id, *groups])
+        end
+
+        subquery = subquery.where(sql.join(" OR "), *sql_args)
+        people = people.where("NOT EXISTS (#{subquery.to_sql})")
+      end
+
       column_names << "lower(people.last_name) AS ordered_last_names"
       people.select(column_names).group("people.id")
     end
@@ -403,4 +599,20 @@ class Search < ActiveRecord::Base
         :max_membership_end_date
       ].any? { |s| send(s).present? }
     end
+    
+    def searching_birthday?
+      [
+        :birth_month,
+        :birth_day,
+        :birth_year
+      ].any? { |s| send(s).present? }
+    end
+    
+    def output_birthday(birth_month, birth_day, birth_year)
+      birthday = []
+      birthday << Date::MONTHNAMES[birth_month] if birth_month.present?
+      birthday << birth_day.to_s if birth_day.present?
+      birthday << birth_year.to_s if birth_year.present?
+      birthday.join(', ')
+    end
 end