artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/job/order_mailer_job.rb

@@ -2,7 +2,6 @@ class OrderMailerJob < Struct.new(:order)
   def perform
     OrderMailer.confirmation_for(order).deliver
   rescue Exception => e
-    Exceptional.context(:order_id => order.id)
-    Exceptional.handle(e, "Could not send order confirmation for order")
+    Airbrake.notify(e, :parameters => {:order_id => order.id})
   end
 end

data/app/models/job/order_processor.rb

@@ -33,6 +33,7 @@ class OrderProcessor < Struct.new(:order, :options)
 
     generate_qr_codes_and_pdf
     send_confirmation
+    send_donation_notification
   end
 
   def generate_qr_codes_and_pdf
@@ -42,17 +43,27 @@ class OrderProcessor < Struct.new(:order, :options)
         generate_pdf if order.organization.can? :access, :scannable_tickets
       end
     rescue Exception => e
-      Exceptional.context(:order_id => order.id)
-      Exceptional.handle(e, "Could not generate PDF for order")
+      Airbrake.notify(e, :parameters => {:error_message => "Could not generate PDF for order", :order_id => order.id})
     end
   end
 
   def send_confirmation
     begin
       OrderMailer.confirmation_for(order).deliver unless skip_email
+    rescue Exception => e 
+      Airbrake.notify(e, :parameters => {:error_message => "Could not send confirmation for order", :order_id => order.id})
+    end
+  end
+
+  def send_donation_notification
+    begin
+      organization = order.organization
+      if !skip_email && organization.has_kit?(:regular_donation) && order.donations.any?
+        recipients = organization.donation_notification_recipients.collect(&:email)
+        recipients.each {|to| ProducerMailer.donation_notification(order, to).deliver}
+      end
     rescue Exception => e
-      Exceptional.context(:order_id => order.id)
-      Exceptional.handle(e, "Could not send order confirmation for order")
+      Airbrake.notify(e, :parameters => {:error_message => "Could not send donation notification for order", :order_id => order.id})
     end
   end
 
@@ -69,7 +80,7 @@ class OrderProcessor < Struct.new(:order, :options)
       self.order.memberships.each do |membership_item|
         Member.for(membership_item.product, self.order.person)
       end
-      self.order.create_generic_action("memberships")
+      self.order.create_generic_action("memberships") unless skip_actions
     end
   end
 
@@ -79,7 +90,7 @@ class OrderProcessor < Struct.new(:order, :options)
         pass_item.product.person = self.order.person
         pass_item.product.save
       end
-      self.order.create_generic_action("passes")
+      self.order.create_generic_action("passes") unless skip_actions
       PassMailer.pass_info_for(self.order.person, self.order.organization.email,self.order.passes.collect(&:product)).deliver
     end
   end

data/app/models/job/person_lifetime_value_job.rb

@@ -4,6 +4,7 @@ class PersonLifetimeValueJob
       p.skip_commit = true
       p.calculate_lifetime_value
       p.calculate_lifetime_donations
+      p.calculate_lifetime_pledges
     end
     Sunspot.delay.commit
   end

data/app/models/job/search_export_job.rb

@@ -0,0 +1,33 @@
+class SearchExportJob < Struct.new(:organization_id, :search_id)
+  include Monitorable
+
+  def perform
+    organization = Organization.find(organization_id)
+    search = Search.find(search_id)
+    segment = Segment.where(:search_id => search_id).first
+
+    Rails.logger.debug(segment.inspect)
+
+    filename = ""
+    if segment.present?
+      filename = "#{segment.name}-#{DateTime.now.strftime("%m-%d-%y")}.csv"
+    else
+      filename = "#{search.id}-#{DateTime.now.strftime("%m-%d-%y")}.csv"
+    end
+    
+    people     = Person.where(:id => search.people.collect(&:id))
+                   .includes(:phones, :addresses, :tags)
+                   .order('lower(people.last_name)')
+    csv_string = people.all.to_comma
+    s3         = S3Coordinator.new
+
+    s3.create_file(filename, csv_string)
+
+    if self.job_monitor.present?
+      self.job_monitor.file_url = s3.download_link(filename, 10*60)
+      self.job_monitor.finished = true
+      self.job_monitor.finished_at = DateTime.now
+      self.job_monitor.save
+    end
+  end
+end

data/app/models/job/suggest_households_by_address_job.rb

@@ -0,0 +1,29 @@
+class SuggestHouseholdsByAddressJob < Struct.new(:address_id)
+  def perform
+    return unless address.present?
+    return unless address.person.present?
+    return unless organization.present?
+
+    matches = organization.people.joins(:addresses).
+      where(:addresses => {:address1 => address.address1, :address2 => address.address2}).
+      where('addresses.zip like ?', address.zip).
+      where('people.household_id is null')
+
+    return unless matches.count > 1
+
+    existing = organization.suggested_households.with_people(matches)
+    unless existing.present? && existing.ignored
+      organization.suggested_households.find_or_create_with_people(matches)
+    end
+  end
+
+  private
+
+  def address
+    @address ||= Address.find(address_id)
+  end
+
+  def organization
+    @organization ||= address.person.organization
+  end
+end

data/app/models/job/suggest_households_by_spouse_job.rb

@@ -0,0 +1,22 @@
+class SuggestHouseholdsBySpouseJob < Struct.new(:relationship_id)
+  def perform
+    return unless relationship.present?
+    return if relationship.person.household.present? || relationship.other.household.present?
+
+    existing = organization.suggested_households.with_people([relationship.person, relationship.other])
+    unless existing.present? && existing.ignored
+      organization.suggested_households.find_or_create_with_people([relationship.person, relationship.other])
+    end
+  end
+
+  private
+
+  def relationship
+    @relationship ||= Relationship.find(relationship_id)
+  end
+
+  def organization
+    @organization ||= relationship.person.organization
+  end
+end
+

data/app/models/job_monitor.rb

@@ -0,0 +1,14 @@
+class JobMonitor < ActiveRecord::Base
+  belongs_to :organization
+
+  def self.enqueue(organization, job, job_options={})
+    job_monitor = self.new
+    job_monitor.organization = organization
+    job_monitor.return_url = job_options.delete(:return_url)
+    job_monitor.save
+    job.job_monitor = job_monitor
+
+    Delayed::Job.enqueue(job, job_options)
+    job_monitor
+  end
+end

data/app/models/kit.rb

@@ -5,21 +5,23 @@ class Kit < ActiveRecord::Base
   belongs_to :organization
   validates_presence_of :organization
 
-  class_attribute :requires_approval, :ability_proc, :configurable, :restricted_to_admins
+  class_attribute :requires_approval, :ability_proc, :configurable, :restricted_to_admins, :activate_without_prejudice, :cancel_with_authority
 
   def self.visible
     where(Kit.arel_table[:state].eq("activated").or(Kit.arel_table[:state].eq('pending')))
   end
 
   def self.acts_as_kit(options = {}, &block)
-    self.requires_approval = options.delete(:with_approval) || false
-    self.restricted_to_admins = options.delete(:admin_only) || false
+    activate_without_prejudice = self.activate_without_prejudice = options.delete(:activate_without_prejudice) || false
+    cancel_with_authority = self.cancel_with_authority = options.delete(:cancel_with_authority) || false
+    requires_approval = self.requires_approval = options.delete(:with_approval) || false
+    restricted_to_admins = self.restricted_to_admins = options.delete(:admin_only) || false
 
     state_machine do
       state :fresh
       state :pending, :enter => :on_pending
       state :activated, :enter => :on_activation
-      state :cancelled
+      state :cancelled, :enter => :kit_cancelled
 
       event(:activate, :success => :record_activation)   { transitions :from => [:fresh, :pending], :to => :activated, :guard => :activatable? }
       event(:approve, :success => :record_approval)    { transitions :from => :pending, :to => :activated, :guard => :approvable? }
@@ -27,12 +29,22 @@ class Kit < ActiveRecord::Base
       event(:cancel)     { transitions :from => [:activated, :pending, :rejected ], :to => :cancelled }
       event(:reactivate) { transitions :from => :cancelled, :to => :activated, :guard => :activatable? }
       event(:activate_without_pending) { transitions :from => [:fresh, :pending, :cancelled], :to => :activated }
-    end
 
-    if self.requires_approval
-      state_machine do
+      if requires_approval
         event(:submit_for_approval) { transitions :from => :fresh, :to => :pending }
       end
+
+      if activate_without_prejudice
+        event :activate_without_prejudice do
+          transitions :from => [:fresh, :activated, :pending, :cancelled], :to => :activated
+        end
+      end
+
+      if cancel_with_authority
+        event :cancel_with_authority do
+          transitions :from => [:fresh, :pending, :activated, :cancelled], :to => :cancelled
+        end
+      end
     end
 
     class_eval(&block)
@@ -102,6 +114,10 @@ class Kit < ActiveRecord::Base
     check_requirements
   end
 
+  def flash_name    
+    friendly_name    
+  end
+
   def activatable?
     return false if organization.nil?
 
@@ -122,6 +138,10 @@ class Kit < ActiveRecord::Base
     check_admin_approval
   end
 
+  def has_active_storefront?
+    false
+  end
+
   class DuplicateError < StandardError
   end
 
@@ -129,6 +149,13 @@ class Kit < ActiveRecord::Base
     def on_activation; end
     def on_pending; end
 
+    def dont_approve
+      false
+    end
+
+    def kit_cancelled
+    end
+
   private
     def check_requirements
       check_unlesses(self.class.activation_requirements[:unless]) and check_ifs(self.class.activation_requirements[:if])
@@ -155,4 +182,4 @@ class Kit < ActiveRecord::Base
     def needs_approval?
       self.class.requires_approval and fresh?
     end
-end
+end

data/app/models/kits/campaigns_kit.rb

@@ -0,0 +1,27 @@
+class CampaignsKit < Kit
+  include ActionView::Helpers::SanitizeHelper
+
+  acts_as_kit :with_approval => true, :admin_only => true do
+    state_machine :auto_scopes => true do
+      state :cancelled, :enter => :kit_cancelled
+      event(:submit_for_approval) { transitions :from => :fresh, :to => :pending }
+    end
+
+    when_active do |organization|
+      organization.can :access, :campaigns
+    end
+  end
+
+  def friendly_name
+    'Campaigns'
+  end
+
+  def flash_name
+    'the Campaigns Kit'
+  end
+
+  def pitch
+    'Set fundraising goals, create appeals, and organize donations.'
+  end
+
+end

data/app/models/kits/mailchimp_kit.rb

@@ -1,15 +1,11 @@
 class MailchimpKit < Kit
-  attr_accessible :api_key
+  attr_accessible :api_key, :default_list_id, :fan_subscribe_question
   QUEUE = "mailchimp"
+  REQUIRED_MERGE_VARS = ["EMAIL", "FNAME", "LNAME", "ADDRESS"]
 
-  acts_as_kit do
+  acts_as_kit :with_approval => true do
     self.configurable = true
 
-    state_machine do
-      state :cancelled, :enter => :kit_cancelled
-      event(:submit_for_approval) { transitions :from => :fresh, :to => :pending }
-    end
-
     when_active do
     end
   end
@@ -22,7 +18,8 @@ class MailchimpKit < Kit
 
   store :settings, :accessors => [
     :api_key, :old_api_key, :attached_lists,
-    :mailchimp_state, :count_from_mailchimp, :count_to_mailchimp, :count_merged_artfully, :count_merged_mailchimp
+    :mailchimp_state, :default_list_id, :fan_subscribe_question,
+    :count_from_mailchimp, :count_merged_mailchimp, :hide_default_list_alert
   ]
 
   def friendly_name
@@ -45,18 +42,49 @@ class MailchimpKit < Kit
   def valid_api_key?
     return unless api_key
     begin
-      gibbon.ping == "Everything's Chimpy!"
+      gibbon.helper.ping["msg"] == "Everything's Chimpy!"
     rescue
       false
     end
   end
 
   def lists
-    gibbon.lists({:start => 0, :limit=> 100})["data"].map do |list|
+    gibbon.lists.list({ :start => 0, :limit => 100 })["data"].map do |list|
       [list["name"], list["id"]]
     end
   end
 
+  def groups(list_id)
+    gibbon.lists.interest_groupings(:id => list_id).map do |grouping|
+      grouping["groups"] = grouping["groups"].map do |group|
+        group.slice("name")
+      end
+      grouping.slice("id", "name", "groups")
+    end
+  rescue Gibbon::MailChimpError
+    # The list might not have groups enabled and throw this error
+    []
+  end
+
+  def cache_groups_for_attached_lists
+    attached_lists.each do |attached_lists|
+      attached_lists[:groups] = groups(attached_lists[:list_id])
+    end
+    save
+  end
+
+  def default_list_id
+    if settings[:default_list_id].present?
+      settings[:default_list_id]
+    elsif attached_lists.one?
+      attached_lists.first[:list_id]
+    end
+  end
+
+  def fan_subscribe_question
+    settings[:fan_subscribe_question] || "Would you like to join our email list?"
+  end
+
   def list_attached?(list_id)
     attached_lists.any? { |list| list[:list_id] == list_id }
   end
@@ -65,7 +93,8 @@ class MailchimpKit < Kit
     added_list_names = []
     added_list_ids = []
     removed_list_names = []
-    lists.each do |list|
+    mailchimp_lists = lists
+    mailchimp_lists.each do |list|
       list_id = list[1]
       if !list_attached?(list_id) && new_list_ids.include?(list_id)
         add_list(list_id)
@@ -76,20 +105,41 @@ class MailchimpKit < Kit
         removed_list_names << find_list_name(list_id)
       end
     end
-    send_updated_lists_email(added_list_ids, added_list_names, removed_list_names)
+
+    # Clean out old synced lists
+    old_lists = attached_lists.select do |list|
+      mailchimp_lists.none? { |mailchimp_list| mailchimp_list[1] == list[:list_id] }
+    end
+    old_lists.each do |list|
+      remove_list(list[:list_id])
+    end
+
+    cache_groups_for_attached_lists
+
+    start_sync(added_list_names, removed_list_names)
   end
 
   def add_list(list_id)
     self.attached_lists = attached_lists.reject { |list| list.empty? }
     attached_lists << {
       :list_id => list_id,
-      :list_name => find_list_name(list_id)
+      :list_name => find_list_name(list_id),
+      :groups => groups(list_id),
     }
     save
   end
 
-  def send_updated_lists_email(added_list_ids, added_list_names, removed_list_names)
-    Delayed::Job.enqueue MailchimpSyncJob.new(self, :type => :initial_sync, :list_ids => added_list_ids, :added_list_names => added_list_names, :removed_list_names => removed_list_names), :queue => QUEUE
+  def start_sync(added_list_names, removed_list_names)
+    list_ids = attached_lists.map do |list|
+      list[:list_id]
+    end
+    job = MailchimpSyncJob.new(self, {
+      :type => :initial_sync,
+      :list_ids => list_ids,
+      :added_list_names => added_list_names,
+      :removed_list_names => removed_list_names,
+    })
+    Delayed::Job.enqueue job, :queue => QUEUE
   end
 
   def remove_list(list_id)
@@ -98,40 +148,52 @@ class MailchimpKit < Kit
   end
 
   def create_webhooks(list_id)
-    gibbon.list_webhook_add({
+    webhook_url = Rails.application.routes.url_helpers.mailchimp_webhook_url(id, {
+      :list_id => list_id,
+      :host => MAILCHIMP_WEBHOOK_URL[:host],
+      :protocol => MAILCHIMP_WEBHOOK_URL[:protocol] || "http",
+    })
+
+    webhooks_for_list = gibbon.lists.webhooks(:id => list_id)
+
+    existing_webhook = webhooks_for_list.detect do |webhook|
+      webhook["url"] == webhook_url
+    end
+
+    return true if existing_webhook
+
+    gibbon.lists.webhook_add({
       :id => list_id,
-      :url => Rails.application.routes.url_helpers.mailchimp_webhook_url(id, :list_id => list_id, :host => MAILCHIMP_WEBHOOK_URL[:host], :protocol => MAILCHIMP_WEBHOOK_URL[:protocol] || "http")
+      :url => webhook_url,
     })
   end
 
   def destroy_webhooks(list_id)
-    gibbon = Gibbon.new(old_api_key || api_key)
-    gibbon.list_webhook_del({
+    gibbon = Gibbon::API.new(old_api_key || api_key)
+    gibbon.lists.webhook_del({
       :id => list_id,
       :url => Rails.application.routes.url_helpers.mailchimp_webhook_url(id, :list_id => list_id, :host => MAILCHIMP_WEBHOOK_URL[:host], :protocol => MAILCHIMP_WEBHOOK_URL[:protocol] || "http")
-    })
+    })["completed"]
   end
 
   def unsubscribe_old_members(list_id)
     organization.people.each do |person|
-      unless person.subscribed_lists.delete(list_id).nil?
-        person.skip_commit = true
-        person.save
+      person.subscribed_lists.where(:list_id => list_id).each do |subscribed_list|
+        subscribed_list.sync = false
+        subscribed_list.destroy
       end
     end
     Sunspot.delay.commit
   end
 
   def sync_mailchimp_to_artfully_new_members(list_id)
-    set_count_from_mailchimp(list_id)
-
-    mailchimp_to_artfully_new_members(list_id).each do |member|
+    members = mailchimp_to_artfully_new_members(list_id)
+    members.each do |member|
       person = organization.people.create({
-        :first_name => member["First Name"],
-        :last_name => member["Last Name"],
-        :email => member["Email Address"],
+        :first_name => member["first name"],
+        :last_name => member["last name"],
+        :email => member["email address"],
         :skip_sync_to_mailchimp => true,
-        :subscribed_lists => [list_id]
       }) do |person|
         person.skip_commit = true
       end
@@ -141,48 +203,73 @@ class MailchimpKit < Kit
       })
       note.organization_id = organization_id
       note.save
+
+      subscribed_list = person.subscribed_lists.create({
+        :list_id => list_id,
+        :sync => false,
+        :confirmed => true,
+      })
+
+      list = attached_lists.detect { |list| list[:list_id] == list_id }
+      create_groups_for_mailchimp_member(list, subscribed_list, member)
     end
+    set_count_from_mailchimp(members.count)
   end
 
   def mailchimp_to_artfully_new_members(list_id)
-    members_not_in_artfully = []
-    mailchimp_list_members(list_id).each do |member|
-      if !organization_people_emails.include?(member["Email Address"])
-        members_not_in_artfully << member
-      end
+    mailchimp_list_members(list_id).reject do |member|
+      organization_people_emails.include?(member["email address"])
     end
-    members_not_in_artfully
   end
 
   def sync_mailchimp_to_artfully_update_members(list_id)
-    set_count_merged_mailchimp(list_id)
-
-    mailchimp_to_artfully_update_members(list_id).each do |member|
-      person = organization.people.find_by_email(member["Email Address"])
+    members = mailchimp_to_artfully_update_members(list_id)
+    members.each do |member|
+      person = organization.people.find_by_email(member["email address"])
 
       next if person.do_not_email?
 
       member.each do |attribute, value|
         attribute = mailchimp_attributes_to_artfully[attribute]
-        if person.send(attribute).blank?
+        if attribute && person.send(attribute).blank?
           person.send("#{attribute}=", value)
         end
       end
 
       person.skip_sync_to_mailchimp = true
-      person.subscribed_lists << list_id
       person.save
+
+      subscribed_list = person.subscribed_lists.find_or_initialize_by_list_id(list_id)
+      subscribed_list.sync = false
+      subscribed_list.confirmed = true
+      subscribed_list.bounced = false
+      subscribed_list.save
+
+      list = attached_lists.detect { |list| list[:list_id] == list_id }
+      create_groups_for_mailchimp_member(list, subscribed_list, member)
     end
+    set_count_merged_mailchimp(members.count)
   end
 
-  def mailchimp_to_artfully_update_members(list_id)
-    members_in_mailchimp = []
-    mailchimp_list_members(list_id).each do |member|
-      if organization_people_emails.include?(member["Email Address"])
-        members_in_mailchimp << member
+  def create_groups_for_mailchimp_member(list, subscribed_list, member)
+    list.fetch(:groups, []).each do |grouping|
+      groups = member[grouping["name"].downcase] || ""
+      groups = groups.split(",").map(&:strip)
+
+      groups.each do |group|
+        subscribed_list.groupings.create({
+          :mailchimp_id => grouping["id"],
+          :name => grouping["name"],
+          :group => group,
+        })
       end
     end
-    members_in_mailchimp
+  end
+
+  def mailchimp_to_artfully_update_members(list_id)
+    mailchimp_list_members(list_id).select do |member|
+      organization_people_emails.include?(member["email address"])
+    end
   end
 
   def sync_merged_loser_to_mailchimp(email)
@@ -192,10 +279,15 @@ class MailchimpKit < Kit
   def sync_merged_winner_to_mailchimp(person_id, new_lists)
     person = Person.find(person_id)
     new_lists.each do |list_id|
-      gibbon.list_subscribe({
+      gibbon.lists.subscribe({
         :id => list_id,
-        :email_address => person.email,
-        :merge_vars => { "FNAME" => person.first_name, "LNAME" => person.last_name },
+        :email => {
+          :email => person.email,
+        },
+        :merge_vars => {
+          "FNAME" => person.first_name,
+          "LNAME" => person.last_name,
+        },
         :double_optin => false
       })
     end
@@ -203,8 +295,11 @@ class MailchimpKit < Kit
 
   def sync_mailchimp_webhook_new_subscriber(list_id, data)
     if person = organization.people.find_by_email(data["email"])
-      person.subscribed_lists << list_id
-      person.save
+      subscribed_list = person.subscribed_lists.where(:list_id => list_id).first
+      subscribed_list ||= person.subscribed_lists.create(:list_id => list_id, :sync => false)
+      subscribed_list.confirmed = true
+      subscribed_list.bounced = false
+      subscribed_list.save
       return sync_mailchimp_webhook_update_person(list_id, data)
     end
 
@@ -213,8 +308,12 @@ class MailchimpKit < Kit
       :last_name => data["merges"]["LNAME"],
       :email => data["email"],
       :skip_sync_to_mailchimp => true,
-      :subscribed_lists => [list_id]
     })
+
+    subscribed_list = person.subscribed_lists.create(:list_id => list_id, :sync => false)
+    subscribed_list.confirmed = true
+    subscribed_list.save
+
     note = person.notes.build({
       :text => "Imported from MailChimp",
       :occurred_at => Time.now
@@ -239,15 +338,33 @@ class MailchimpKit < Kit
       person.send("#{attribute}=", value) if attribute
     end
 
-    person.subscribed_lists.each do |subscribed_list_id|
-      next if subscribed_list_id == list_id
-      gibbon.list_update_member({
-        :id => subscribed_list_id,
-        :email_address => person.email,
+    subscribed_list = person.subscribed_lists.where(:list_id => list_id).first
+    if subscribed_list
+      data["merges"].fetch("GROUPINGS", {}).each do |_, grouping|
+        # Clear out all groupings so we only have an up to date list
+        subscribed_list.groupings.where(:name => grouping["name"]).delete_all
+        groups = grouping["groups"].split(",").map(&:strip)
+        groups.each do |group|
+          subscribed_list.groupings.create({
+            :mailchimp_id => grouping["id"],
+            :name => grouping["name"],
+            :group => group,
+          })
+        end
+      end
+    end
+
+    person.subscribed_lists.not_bounced.each do |subscribed_list|
+      next if subscribed_list.list_id == list_id
+      gibbon.lists.update_member({
+        :id => subscribed_list.list_id,
+        :email => {
+          :email => person.email,
+        },
         :merge_vars => {
           "FNAME" => person.first_name,
-          "LNAME" => person.last_name
-        }
+          "LNAME" => person.last_name,
+        },
       })
     end
 
@@ -261,7 +378,11 @@ class MailchimpKit < Kit
     return if person.nil?
 
     reason = (data["reason"] == "hard" ? "a hard bounce" : "abuse")
-    person.subscribed_lists.delete(list_id)
+    person.subscribed_lists.where(:list_id => list_id).each do |subscribed_list|
+      subscribed_list.bounced = true
+      subscribed_list.confirmed = true
+      subscribed_list.save
+    end
     person.new_note("MailChimp cleaned #{person.email} from #{list_name(list_id)} because of #{reason}.", Time.now, nil, organization_id)
     person.save
   end
@@ -271,11 +392,13 @@ class MailchimpKit < Kit
     return if person.nil? || person.do_not_email?
     person.update_attributes(:email => data["new_email"], :skip_sync_to_mailchimp => true)
 
-    person.subscribed_lists.each do |subscribed_list_id|
-      next if subscribed_list_id == list_id
-      gibbon.list_update_member({
-        :id => subscribed_list_id,
-        :email_address => data["old_email"],
+    person.subscribed_lists.each do |subscribed_list|
+      next if subscribed_list.list_id == list_id
+      gibbon.lists.update_member({
+        :id => subscribed_list.list_id,
+        :email => {
+          :email => data["old_email"],
+        },
         :merge_vars => {
           "EMAIL" => data["new_email"]
         }
@@ -291,40 +414,201 @@ class MailchimpKit < Kit
     person = organization.people.find_by_email(data["email"])
     return unless person
     person.new_note("Unsubscribed in MailChimp from #{list_name(list_id)}", Time.now, nil, organization_id)
-    person.subscribed_lists.delete(list_id)
+    person.subscribed_lists.where(:list_id => list_id).each do |subscribed_list|
+      subscribed_list.sync = false
+      subscribed_list.destroy
+    end
+    person.opted_out_lists << list_id
+    person.opted_out_lists.uniq!
     person.save
   end
 
+  def list_attached?(list_id)
+    attached_lists.detect do |list|
+      list[:list_id] == list_id
+    end
+  end
+
   def sync_mailchimp_webhook_campaign_sent(list_id, data)
-    occurred_at = Time.now
+    return unless list_attached?(list_id)
+    Rails.logger.debug("MAILCHIMP sync_mailchimp_webhook_campaign_sent: Starting sync")
+    start = Time.now
 
+    occurred_at = Time.now
     emails = []
 
+    page = 0
     begin
-      response = gibbon.campaign_members(:cid => data["id"])
+      response = gibbon.reports.sent_to(:cid => data["id"], :opts => {:start => page, :limit => 100})
       response["data"].each do |user|
-        emails << user["email"]
+        emails << user.fetch("member").fetch("email")
       end
+      page += 1
     end while response["total"] > emails.count
-
-    organization.people.each do |person|
-      next if !person.subscribed_lists.include?(list_id)
-      next if !emails.include?(person.email)
-      hear_action = HearAction.for_organization(organization)
-      hear_action.details = %{"#{data["subject"].truncate(25)}" delivered to #{list_name(list_id)} MailChimp list.}
+    Rails.logger.debug("MAILCHIMP sync_mailchimp_webhook_campaign_sent: [#{emails.count}] emails found")
+
+    system_action = SystemAction.for_organization(organization)
+    system_action.details = %{"#{data["subject"]}" delivered to #{emails.count} subscribers of #{list_name(list_id)}.}
+    system_action.subtype = "Mailchimp (Sent)"
+    system_action.save
+
+    people_ids = organization.people
+                       .joins(:subscribed_lists)
+                       .where(:deleted_at => nil)
+                       .where(:email => emails)
+                       .where(:do_not_email => false)
+                       .where('subscribed_lists.list_id = ?', list_id)
+                       .pluck(:id)
+    Rails.logger.debug("MAILCHIMP sync_mailchimp_webhook_campaign_sent: [#{people_ids.length}] people found")
+
+    hear_actions = []
+
+    people_ids.each_with_index do |person_id, index|
+      hear_action = MailchimpHearAction.for_organization(organization)
+      hear_action.details = %{"#{data["subject"].truncate(25)}" via #{list_name(list_id)} MailChimp list.}
       hear_action.occurred_at = occurred_at
       hear_action.subtype = "Mailchimp (Sent)"
-      hear_action.person = person
-      hear_action.save
+      hear_action.person_id = person_id
+      hear_action.hide_on_recent_activity = true
+      hear_action.external_reference = data["id"]
+      hear_actions << hear_action
+
+      if ((index+1) % 100 == 0)
+        hear_actions = flush_actions(hear_actions)
+      end
+    end
+
+    # Final flush
+    hear_actions = flush_actions(hear_actions)
+
+    Rails.logger.debug("MAILCHIMP sync_mailchimp_webhook_campaign_sent: Finished with people")
+    schedule_open_check(data["id"], 1.hour.from_now)
+
+    finish = Time.now
+    Rails.logger.debug("MAILCHIMP sync_mailchimp_webhook_campaign_sent: took #{finish-start} seconds")
+    AdminMailer.mailchimp_sent(organization, data, list_id, emails, people_ids.length, finish - start).deliver
+  end
+
+  def flush_actions(hear_actions)
+    if !hear_actions.empty?
+      Rails.logger.debug("MAILCHIMP sync_mailchimp_webhook_campaign_sent: Importing [#{hear_actions.length}] actions")
+      HearAction.import hear_actions
+      Rails.logger.debug("MAILCHIMP sync_mailchimp_webhook_campaign_sent: Flushing actions")
+      hear_actions = []
+    end
+    hear_actions
+  end
+
+  def sync_artfully_open_check(campaign_id)
+    members = []
+
+    page = 0
+    begin
+      response = gibbon.reports.opened(:cid => campaign_id, :opts => {:start => page})
+      response["data"].each do |member|
+        members << {
+          :email => member.fetch("member").fetch("email"),
+          :opened? => member.fetch("opens").to_i > 0,
+        }
+      end
+      page += 1
+    end while response["total"].to_i > members.count
+
+    response = gibbon.campaigns.list(:filters => { :campaign_id => campaign_id })
+    campaign = response["data"].first
+
+    occurred_at = Time.now
+
+    utc = ActiveSupport::TimeZone.new("UTC")
+    send_time = utc.parse(campaign["send_time"])
+
+    members.each do |member|
+      next unless member[:opened?]
+
+      person = organization.people.find_by_email(member[:email])
+      next unless person
+
+      action = person.actions.where({
+        :type => MailchimpHearAction,
+        :external_reference => campaign_id,
+      }).first
+      next unless action
+
+      next unless action.subtype == "Mailchimp (Sent)"
+
+      action.details = %{"#{campaign["subject"].truncate(25)}" via the #{list_name(campaign["list_id"])} MailChimp list.}
+      action.subtype = "Mailchimp (Opened)"
+      action.occurred_at = occurred_at
+      action.save
+    end
+
+    difference = Time.now.utc - send_time
+    if difference < 1.week
+      schedule_open_check(campaign_id, 1.hour.from_now)
+    elsif 1.week < difference && difference < 2.weeks
+      schedule_open_check(campaign_id, 1.day.from_now)
+    end
+  end
+
+  def schedule_open_check(campaign_id, time)
+    job = MailchimpSyncJob.new(self, {
+      :type => "open_check",
+      :campaign_id => campaign_id,
+    })
+    Delayed::Job.enqueue(job, :queue => QUEUE, :run_at => time)
+  end
+
+  def sync_artfully_grouping_update(person_id)
+    person = Person.find_by_id(person_id)
+    return unless person
+    person.subscribed_lists.each do |subscribed_list|
+      list = attached_lists.detect do |list|
+        list[:list_id] == subscribed_list.list_id
+      end
+      next unless list
+      groupings = list.fetch(:groups, []).map do |group|
+        groups = subscribed_list.groupings.where(:name => group["name"])
+        {
+          :id => group["id"],
+          :groups => groups.map(&:group),
+        }
+      end
+
+      gibbon.lists.update_member({
+        :id => subscribed_list.list_id,
+        :email => {
+          :email => person.email,
+        },
+        :merge_vars => {
+          "GROUPINGS" => groupings,
+        },
+      })
     end
   end
 
-  def sync_artfully_person_update(person_id, person_changes)
+  def sync_artfully_person_subscribe(person_id, new_list_id, single_optin)
+    person = organization.people.find_by_id(person_id)
+    return unless person
+    subscribe_email(person.email, person.first_name, person.last_name, new_list_id, !single_optin)
+  end
+
+  def sync_artfully_person_unsubscribe(person_id, new_list_id)
+    person = organization.people.find_by_id(person_id)
+    return unless person
+    unsubscribe_email(person.email, new_list_id)
+  end
+
+  #
+  # The API here is unclear. Sometimes this returns true, sometimes nothing
+  # and sometimes the array of subscribed lists
+  #
+  def sync_artfully_person_update(person_id, person_changes, bounced_list_ids = [])
     person = organization.people.find_by_id(person_id)
 
     return unless person
 
     merge_vars = {}
+
     merge_vars["FNAME"] = person_changes["first_name"][1] if person_changes["first_name"]
     merge_vars["LNAME"] = person_changes["last_name"][1] if person_changes["last_name"]
     email = person_changes["email"] ? person_changes["email"][0] : person.email
@@ -335,56 +619,188 @@ class MailchimpKit < Kit
       end
     end
 
-    if person_changes.has_key?("subscribed_lists")
-      return attached_lists.all? do |list|
-        old_lists = person_changes["subscribed_lists"][0]
-        new_lists = person_changes["subscribed_lists"][1]
-        if !old_lists.include?(list[:list_id]) && new_lists.include?(list[:list_id])
-          first_name = merge_vars["FNAME"] || person.first_name
-          last_name = merge_vars["LNAME"] || person.last_name
-          subscribe_email(email, first_name, last_name, list[:list_id])
-        elsif old_lists.include?(list[:list_id]) && !new_lists.include?(list[:list_id])
-          unsubscribe_email(email, list[:list_id])
-        else
-          true
-        end
-      end
-    end
-
     return unless sync_person?(person)
 
     merge_vars["EMAIL"] = person_changes["email"][1] if person_changes["email"]
 
     # go over the person's subscribed lists and update them
-    person.subscribed_lists.each do |list_id|
-      next unless attached_lists.any? { |list| list[:list_id] == list_id }
-      gibbon.list_update_member({
-        :id => list_id,
-        :email_address => email,
+    person.subscribed_lists.each do |subscribed_list|
+      next unless attached_lists.any? { |list| list[:list_id] == subscribed_list.list_id }
+
+      # Bounced emails are no longer subscribed so we should
+      # resubscribe them without sending a notification
+      if merge_vars.has_key?("EMAIL") && bounced_list_ids.include?(subscribed_list.id)
+        subscribe_email(merge_vars["EMAIL"], person.first_name, person.last_name, subscribed_list.list_id, false)
+        next
+      end
+
+      gibbon.lists.update_member({
+        :id => subscribed_list.list_id,
+        :email => {
+          :email => email,
+        },
         :merge_vars => merge_vars
       })
     end
   end
 
+  def sync_artfully_segment(segment_id, list_id)
+    segment = organization.segments.find(segment_id)
+    return unless segment
+    sync_artfully_people_to_mailchimp(segment.people, list_id)
+  end
+
+  def sync_artfully_search(search_id, list_id)
+    search = organization.searches.find(search_id)
+    return unless search
+    sync_artfully_people_to_mailchimp(search.people, list_id)
+  end
+
+  def sync_artfully_advanced_search_segment(advanced_search_segment_id, list_id)
+    advanced_search_segment = organization.advanced_search_segments.find(advanced_search_segment_id)
+    return unless advanced_search_segment
+    sync_artfully_people_to_mailchimp(advanced_search_segment.all_people, list_id)
+  end
+
+  def sync_artfully_advanced_search(advanced_search_id, list_id)
+    advanced_search = organization.advanced_searches.find(advanced_search_id)
+    return unless advanced_search
+    sync_artfully_people_to_mailchimp(advanced_search.all_people, list_id)
+  end
+
+  def sync_artfully_people_to_mailchimp(people, list_id)
+    mailchimp_emails = mailchimp_list_members(list_id).map { |member| member["email address"] }
+
+    # find everyone not in mailchimp list
+    subscribe_people = people.select do |person|
+      person.email.present? && !mailchimp_emails.include?(person.email)
+    end
+
+    subscribe_people.each do |person|
+      subscribe_email(person.email, person.first_name, person.last_name, list_id)
+      person.subscribed_lists.create(:list_id => list_id, :sync => false)
+    end
+  end
+
+  def sync_artfully_segment_add_group(segment_id, grouping)
+    segment = organization.segments.find(segment_id)
+    return unless segment
+    sync_artfully_people_add_group(segment.people, grouping)
+  end
+
+  def sync_artfully_search_add_group(search_id, grouping)
+    search = organization.searches.find(search_id)
+    return unless search
+    sync_artfully_people_add_group(search.people, grouping)
+  end
+
+  def sync_artfully_advanced_search_segment_add_group(advanced_search_segment_id, grouping)
+    advanced_search_segment = organization.advanced_search_segments.find(advanced_search_segment_id)
+    return unless advanced_search_segment
+    sync_artfully_people_add_group(advanced_search_segment.all_people, grouping)
+  end
+
+  def sync_artfully_advanced_search_add_group(advanced_search_id, grouping)
+    advanced_search = organization.advanced_searches.find(advanced_search_id)
+    return unless advanced_search
+    sync_artfully_people_add_group(advanced_search.all_people, grouping)
+  end
+
+  def sync_artfully_people_add_group(people, grouping)
+    grouping_id, group = grouping.split("|")
+
+    list = attached_lists.detect do |list|
+      list.fetch(:groups, []).any? do |grouping|
+        grouping["id"] == grouping_id.to_i
+      end
+    end
+    return unless list
+
+    grouping = list.fetch(:groups, []).detect do |grouping|
+      grouping["id"] == grouping_id.to_i
+    end
+    return unless grouping
+
+    mailchimp_emails = mailchimp_list_members(list[:list_id]).map { |member| member["email address"] }
+
+    # find everyone in mailchimp list
+    subscribed_people = people.select do |person|
+      person.email.present? && mailchimp_emails.include?(person.email)
+    end
+    subscribed_people.each do |person|
+      subscribed_list = person.subscribed_lists.where(:list_id => list[:list_id]).first
+      next unless subscribed_list
+
+      list_grouping = subscribed_list.groupings.create({
+        :mailchimp_id => grouping_id,
+        :name => grouping["name"],
+        :group => group,
+      })
+
+      sync_artfully_grouping_update(person.id) if list_grouping.persisted?
+    end
+  end
+
   def mailchimp_list_members(list_id)
-    return @mailchimp_list_members if @mailchimp_list_members
     response = mailchimp_exporter.list(:id => list_id).to_a
     headers = JSON.parse(response.shift)
+    headers.map!(&:downcase)
     members = response.map { |line| JSON.parse(line) }
 
-    @mailchimp_list_members ||= members.collect do |member|
-      member_hash = {}
+    merge_variables = list_merge_variables(list_id)
+
+    headers = headers.map do |header|
+      if merge_variables.has_key?(header)
+        merge_variables[header]
+      else
+        header
+      end
+    end
+
+    grouping_headers = attached_lists.flat_map do |list|
+      list.fetch(:groups, []).map { |group| group["name"] }
+    end.map(&:downcase)
 
-      mailchimp_attributes.inject({}) do |member_hash, attribute|
-        member_hash[attribute] = member[headers.index(attribute)] unless headers.index(attribute).nil?
+    members.collect do |member|
+      member_hash = {}
+      attributes = mailchimp_attributes + grouping_headers
+      attributes.inject({}) do |member_hash, attribute|
+        unless headers.index(attribute).nil?
+          member_hash[attribute] = member[headers.index(attribute)]
+        end
         member_hash
       end
     end
   end
 
+  def list_merge_variables(list_id)
+    response = gibbon.lists.merge_vars(:id => [list_id])
+    list = response["data"].first
+    variables = list["merge_vars"]
+    variables.inject({}) do |hash, variable|
+      case variable["tag"]
+      when "EMAIL"
+        hash[variable["name"].downcase] = "email address"
+      when "FNAME"
+        hash[variable["name"].downcase] = "first name"
+      when "LNAME"
+        hash[variable["name"].downcase] = "last name"
+      end
+      hash
+    end
+  end
+
+  def default_list?
+    default_list_id.present?
+  end
+
+  def display_default_list_alert?
+    api_key.present? && !default_list? && !hide_default_list_alert
+  end
+
   private
   def gibbon
-    @gibbon ||= Gibbon.new(api_key)
+    @gibbon ||= Gibbon::API.new(api_key)
   end
 
   def mailchimp_exporter
@@ -398,14 +814,14 @@ class MailchimpKit < Kit
   end
 
   def mailchimp_attributes
-    ["Email Address", "First Name", "Last Name"]
+    ["email address", "first name", "last name"]
   end
 
   def mailchimp_attributes_to_artfully
     {
-      "Email Address" => "email",
-      "First Name" => "first_name",
-      "Last Name" => "last_name"
+      "email address" => "email",
+      "first name" => "first_name",
+      "last name" => "last_name"
     }
   end
 
@@ -413,12 +829,12 @@ class MailchimpKit < Kit
     {
       "EMAIL" => "email",
       "FNAME" => "first_name",
-      "LNAME" => "last_name"
+      "LNAME" => "last_name",
     }
   end
 
   def organization_people_emails
-    @organization_people_emails ||= organization.people.pluck(:email)
+    organization.people.pluck(:email)
   end
 
   def kit_cancelled
@@ -429,13 +845,13 @@ class MailchimpKit < Kit
     Delayed::Job.enqueue(MailchimpSyncJob.new(self, :type => "kit_cancelled"), :queue => QUEUE)
   end
 
-  def set_count_from_mailchimp(list_id)
-    self.count_from_mailchimp = mailchimp_to_artfully_new_members(list_id).count
+  def set_count_from_mailchimp(count)
+    self.count_from_mailchimp = (count_from_mailchimp || 0) + count
     save
   end
 
-  def set_count_merged_mailchimp(list_id)
-    self.count_merged_mailchimp = mailchimp_to_artfully_update_members(list_id).count
+  def set_count_merged_mailchimp(count)
+    self.count_merged_mailchimp = (count_merged_mailchimp || 0) + count
     save
   end
 
@@ -451,21 +867,29 @@ class MailchimpKit < Kit
     end
 
     lists.each do |list_id|
-      gibbon.list_unsubscribe({
+      gibbon.lists.unsubscribe({
         :id => list_id,
-        :email_address => email,
+        :email => {
+          :email => email,
+        },
         :send_goodbye => false,
         :send_notify => false,
-        :delete_member => true
+        :delete_member => true,
       })
     end
   end
 
-  def subscribe_email(email, first_name, last_name, list_id)
-    response = gibbon.list_subscribe({
+  def subscribe_email(email, first_name, last_name, list_id, send_optin = true)
+    response = gibbon.lists.subscribe({
       :id => list_id,
-      :email_address => email,
-      :merge_vars => { "FNAME" => first_name, "LNAME" => last_name }
+      :email => {
+        :email => email,
+      },
+      :double_optin => send_optin,
+      :merge_vars => {
+        "FNAME" => first_name,
+        "LNAME" => last_name,
+      },
     })
   end