artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/door_list.rb

@@ -17,16 +17,51 @@ class DoorList
   private
 
     class Item
-      attr_accessor :ticket, :buyer, :special_instructions, :notes, :payment_method, :order_id
+      attr_accessor :ticket, :buyer, :special_instructions, :notes, :payment_method, :order_id, :addresses, :phones
       
       comma do
+        order_id "Order Number"
+        buyer("Email")                  { |buyer| buyer.email }
+        buyer("Salutation")             { |buyer| buyer.salutation }
         buyer("First Name")             { |buyer| buyer.first_name }
+        buyer("Middle Name")            { |buyer| buyer.middle_name }
         buyer("Last Name")              { |buyer| buyer.last_name }
-        buyer("Email")                  { |buyer| buyer.email }
+        buyer("Suffix")                 { |buyer| buyer.suffix }
+        buyer("Title")                  { |buyer| buyer.title }
+        buyer("Type")                   { |buyer| buyer.type }
+        buyer("Sub Type")               { |buyer| buyer.subtype }
+        buyer("Company Name")           { |buyer| buyer.company_name }
+
+        ('A'..'C').each_with_index do |letter, i|
+          addresses("Address#{letter} Type")        { |addresses| addresses[i] && addresses[i].kind }
+          addresses("Address#{letter} Address 1")   { |addresses| addresses[i] && addresses[i].address1 }
+          addresses("Address#{letter} Address 2")   { |addresses| addresses[i] && addresses[i].address2 }
+          addresses("Address#{letter} City")        { |addresses| addresses[i] && addresses[i].city }
+          addresses("Address#{letter} State")       { |addresses| addresses[i] && addresses[i].state }
+          addresses("Address#{letter} Zip")         { |addresses| addresses[i] && addresses[i].zip }
+          addresses("Address#{letter} Country")     { |addresses| addresses[i] && addresses[i].country }
+        end
+
+        (1..3).each do |i|
+          phones("Phone#{i} type")          { |phones| phones[i-1] && phones[i-1].kind }
+          phones("Phone#{i} number")        { |phones| phones[i-1] && phones[i-1].number }
+        end
+
+        buyer("Website")                { |buyer| buyer.website }
+        buyer("Twitter Handle")         { |buyer| buyer.twitter_handle }
+        buyer("Facebook URL")           { |buyer| buyer.facebook_url }
+        buyer("LinkedIn URL")           { |buyer| buyer.linked_in_url }
+        buyer("Tags")                   { |buyer| buyer.tags.join("|") }
+        buyer("Do Not Email")           { |buyer| buyer.do_not_email }
+        buyer("Do Not Call")            { |buyer| buyer.do_not_call }
+        buyer("Birth Month")            { |buyer| buyer.birth_month }
+        buyer("Birth Day")              { |buyer| buyer.birth_day }
+        buyer("Birth Year")             { |buyer| buyer.birth_year }
         ticket("Ticket Type")           { |ticket| ticket.ticket_type.name }
         ticket("Price")                 { |ticket| DoorList.number_as_cents ticket.sold_price }
         ticket("Special Instructions")  { |ticket| ticket.special_instructions }
         ticket("Notes")                 { |ticket| ticket.notes }
+        ticket("Went")                  { |ticket| ticket.validated }
       end
 
       def initialize(ticket, buyer)
@@ -38,6 +73,8 @@ class DoorList
         self.notes = ticket.notes
         self.payment_method = sold_item.try(:order).try(:payment_method)
         self.order_id = sold_item.try(:order).try(:id)
+        self.addresses = buyer.addresses
+        self.phones = buyer.phones
       end
 
       def <=>(obj)

data/app/models/event.rb

@@ -4,14 +4,14 @@ class Event < ActiveRecord::Base
   include Ext::Uuid
   include Ticket::Reporting
   include EventPresenter
+  include OhNoes::Destroy
   require 'email_validator'
 
   CATEGORIES = ["Dance", "Film & Electronic Media", "Literary Arts", "Music", "Theater", "Visual Arts", "Other"]
   
   attr_accessible :name, :producer, :description, :contact_email, :contact_phone, :image, :venue_attributes,
                   :show_special_instructions, :special_instructions_caption, :public, :primary_category,
-                  :secondary_categories, :primary_category_other, :secondary_category_other, :members_only,
-                  :subtitle
+                  :secondary_categories, :primary_category_other, :secondary_category_other, :members_only, :subtitle
 
   store :cached_stats, :accessors => [ :on_sale, :off_sale, :sold, :sales_total ]
 
@@ -53,8 +53,10 @@ class Event < ActiveRecord::Base
   serialize :secondary_categories, Array
 
   default_scope where(:deleted_at => nil).order("events.created_at DESC")
+  scope :storefront, where(:deleted_at => nil).where(:public => true)
   scope :published, includes(:shows).where(:shows => { :state => "published" })
   scope :public, where(:public => true)
+  scope :not_deleted, where('deleted_at IS NULL')
 
   delegate :time_zone, :to => :venue
 
@@ -97,23 +99,27 @@ class Event < ActiveRecord::Base
   def artfully_ticketed
     true
   end
-
-  alias :destroy! :destroy
-  def destroy
-    update_attribute(:deleted_at, Time.now)
-  end
-
+  
   def single_show?
     shows.length == 1
   end
 
   #
-  # The list of events do be deplayed on their event index
+  # The list of events to be displayed on their event index
   #
   def self.for_event_storefront(organization, member = nil)
-    event_rel = organization.events.joins(:shows).where('shows.datetime > ?', DateTime.now).group(:event_id).public
-    event_rel = event_rel.where(:members_only => false) if member.nil?
-    event_rel.all
+    event_ids = organization.shows
+                            .published
+                            .joins(:event)
+                            .where('datetime > ?', DateTime.now)
+                            .merge(Event.storefront)
+                            .reorder('datetime asc')
+                            .pluck(:event_id)
+                            .uniq
+    events = []
+    event_ids.each {|id| events << Event.includes(:venue).find(id)}
+    events.reject!{|e| e.members_only} if member.nil?
+    events
   end
 
   #
@@ -163,10 +169,16 @@ class Event < ActiveRecord::Base
   #
   # You'll almost always want upcoming_public_shows instead
   #
-  def upcoming_shows(limit = 5)
+  def upcoming_shows(limit = 5, reload = false)
     shows_rel = upcoming_shows_rel
     shows_rel = upcoming_shows_rel.limit(limit) unless limit == :all
-    @upcoming ||= shows_rel.all
+    
+    if reload
+      @upcoming = shows_rel.all
+    else
+      @upcoming ||= shows_rel.all
+    end
+    
     @upcoming
   end
 
@@ -180,8 +192,12 @@ class Event < ActiveRecord::Base
     upcoming_public_shows.empty? ? nil : upcoming_public_shows.first
   end
 
+  def next_show_include_unpublished
+    upcoming_shows.empty? ? nil : upcoming_shows.first
+  end
+
   def upcoming_public_shows
-    upcoming_shows(:all).select(&:published?)
+    upcoming_shows(:all, true).select(&:published?)
   end
 
   def next_show

data/app/models/ext.rb

@@ -38,10 +38,10 @@ module Ext
   module S3Link
     def download_link_for(field)
       s3 = AWS::S3.new(
-          :access_key_id     => ENV['S3_ACCESS_KEY_ID'],
-          :secret_access_key => ENV['S3_SECRET_ACCESS_KEY']
+          :access_key_id     => Rails.configuration.s3.access_key_id,
+          :secret_access_key => Rails.configuration.s3.secret_access_key
       )
-      bucket = s3.buckets[ENV['S3_BUCKET']]
+      bucket = s3.buckets[Rails.configuration.s3.bucket]
       object = bucket.objects[self.send(field).path]
       url    = object.url_for(:read, :expires => 10*60)
       url.to_s

data/app/models/ext/delayed_indexing.rb

@@ -8,17 +8,57 @@ module Ext
       base.class_eval do
         handle_asynchronously :solr_index
         handle_asynchronously :solr_index!
-        after_commit { Sunspot.delay.commit }
+        after_commit :commit_to_index, :unless => lambda { @skip_commit == true }
       end
     end
 
     module ClassMethods
       def search_index(query, organization)
+        query_stripped_of_punctuation = query.gsub(/[^a-zA-Z0-9\@\.]/i, "")
+        query_stripped_of_non_letters_and_numbers = query.gsub(/[^a-zA-Z0-9]/, "")
+        
+        if query_stripped_of_punctuation.length > 0 &&
+           query_stripped_of_punctuation.length == query_stripped_of_non_letters_and_numbers.length
+
+           query = query_stripped_of_non_letters_and_numbers
+        end
+
         self.search do
           fulltext query
           with(:organization_id).equal_to(organization.id)
         end.results
       end
+
+      def commit_to_index
+        RedisManager.burst_job("sunspot:commit", 5) do
+          Sunspot.delay(:run_at => 5.seconds.from_now).commit
+        end
+      end
+
+      #
+      # Reindex a bunch of IndexedThings.
+      #
+      # Useful for when you've done some action that modifies a bunch of IndexedThings
+      # but didn't go through the IndexedThing to do it.
+      #
+      # This will kick off a DJ to index each thing. Calling this method synchronously
+      # is discouraged as it has to load all the things.
+      #
+      # If you do all this method asynchronously, **PLEASE NOTE** that if ids.length > 15000,
+      # you'll probably overrun the TEXT field of DelayedJob and cause the job to error on load
+      #
+      # Sunspot offers a Sunspot.index [thing1, thing2] method. We aren't using that
+      # because a large number of things (> 60) can overrun the TEXT column of delayed_jobs
+      # So, this method will slot in 1 Delayed::Job for each thing in ids.
+      #
+      def index_these(ids)
+        self.where(:id => ids).find_in_batches do |things| 
+          things.each do |thing|
+            thing.solr_index
+          end
+        end
+        Sunspot.delay.commit
+      end
     end
   end
 end

data/app/models/ext/integrations.rb

@@ -34,6 +34,8 @@ module Ext
                      .includes(:sections => :ticket_types)
                      .where('shows.id = ?', self.id)
                      .where("ticket_types.#{channel} = ?", true)
+                     .where("ticket_types.deleted_at is null")
+                     .order("ticket_types.price desc")
 
         chart.first
       end
@@ -58,6 +60,10 @@ module Ext
         false
       end
 
+      def administrator_limited?
+        false
+      end
+
       def fsp
         nil
       end

data/app/models/forwarding_job_monitor.rb

@@ -0,0 +1,2 @@
+class ForwardingJobMonitor < JobMonitor
+end

data/app/models/household.rb

@@ -8,7 +8,7 @@ class Household < ActiveRecord::Base
 
   accepts_nested_attributes_for :address, :allow_destroy => false
 
-  validates :name, :uniqueness => true
+  validates :name, :presence => true, :uniqueness => { :scope => :organization_id }
 
   def lifetime_value
     individuals.sum(:lifetime_value)

data/app/models/import.rb

@@ -10,6 +10,11 @@ class Import < ActiveRecord::Base
   has_many :actions, :dependent => :destroy
   has_many :events, :dependent => :destroy
   has_many :orders, :dependent => :destroy
+  has_many :campaigns, :dependent => :destroy
+  has_many :appeals, :dependent => :destroy
+  has_many :members, :dependent => :destroy
+  has_many :memberships, :dependent => :destroy
+  has_many :membership_types, :dependent => :destroy
 
   serialize :import_headers
   
@@ -30,6 +35,8 @@ class Import < ActiveRecord::Base
       PeopleImport.new
     when "donations"
       DonationsImport.new
+    when "memberships"
+      MembershipsImport.new
     else
       nil
     end
@@ -58,6 +65,8 @@ class Import < ActiveRecord::Base
     self.people.destroy_all
     self.import_errors.delete_all
 
+    before_import
+
     rows.each_with_index do |row, index|
       begin
         Rails.logger.info("----- Import #{id} Processing row #{index} ------")
@@ -69,7 +78,11 @@ class Import < ActiveRecord::Base
     end
     self.imported!
   end
-  
+
+  def before_import
+
+  end
+
   #
   # This composes errors thrown *during* the import.  For validation errors, see invalidate!
   #
@@ -80,7 +93,7 @@ class Import < ActiveRecord::Base
     failed!
     rollback
   end
-  
+
   #Subclasses must implement process and rollback
   def process(parsed_row)
   end
@@ -95,8 +108,8 @@ class Import < ActiveRecord::Base
   def parsed_rows
     return @parsed_rows if @parsed_rows
     @parsed_rows = []
-    
-    rows.each do |row|
+
+    rows.each_with_index do |row, index|
       @parsed_rows << ParsedRow.parse(headers, row)
     end
     @parsed_rows
@@ -117,13 +130,15 @@ class Import < ActiveRecord::Base
         #TODO: Validate headers right here
         self.save!
       else
-        self.import_rows.create!(:content => row.to_a)
         parsed_row = ParsedRow.parse(self.import_headers, row.to_a)
-        
         unless row_valid?(parsed_row)
-          self.invalidate! 
+          self.invalidate!
           return
         end
+
+        import_row = index_parsed_row(parsed_row)
+        import_row.content = row.to_a
+        import_row.save!
       end
     end
 
@@ -142,6 +157,10 @@ class Import < ActiveRecord::Base
     self.invalidate!
   end
 
+  def index_parsed_row(parsed_row)
+    self.import_rows.build
+  end
+
   def hash_address(parsed_row)
     parsed_row.address_attributes
   end
@@ -156,9 +175,21 @@ class Import < ActiveRecord::Base
       person.type = "Individual"
     end
 
-    person.build_address(hash_address(parsed_row))
     person.tag_list = parsed_row.tags_list.join(", ")
 
+
+    ('A'..'C').each do |n|
+      address = Address.new(address1: parsed_row.send("address#{n}_address1"),
+                            address2: parsed_row.send("address#{n}_address2"),
+                            city: parsed_row.send("address#{n}_city"),
+                            state: parsed_row.send("address#{n}_state"),
+                            zip: parsed_row.send("address#{n}_zip"),
+                            country: parsed_row.send("address#{n}_country"),
+                            kind: parsed_row.send("address#{n}_type"),
+                            is_primary: (n == 'A'))
+      person.addresses << address unless address.blank?
+    end
+
     1.upto(3) do |n|
       kind = parsed_row.send("phone#{n}_type")
       number = parsed_row.send("phone#{n}_number")

data/app/models/imports/donations_import.rb

@@ -2,22 +2,46 @@ class DonationsImport < Import
   include Imports::Rollback
   include Imports::Validations
   include ArtfullyOseHelper
-  
+
+
   def kind
     "donations"
   end
   
   def process(parsed_row)
     row_valid?(parsed_row)
-    person        = create_person(parsed_row)
-    contribution  = create_contribution(parsed_row, person)
+    person = create_person(parsed_row)
+    create_contribution(parsed_row, person)
   end
   
   def rollback 
     rollback_orders
     rollback_people
+    rollback_campaigns
+    rollback_appeals
   end
-  
+
+  def before_import
+    # Delayed::Worker.logger.add(Logger::INFO, "--------------- before campaigns_data ---------")
+    @campaigns_hash = {} #{campaign_name => {start_date => xxx_date, end_date => xxx_date, goal => xxx_amount, id=xxx}}
+    parsed_rows.each do |parsed_row, index|
+      unless parsed_row.campaign.blank?
+        campaign = parsed_row.campaign
+        occurred_at = parsed_row.donation_date.blank? ? time_zone_parser.now : time_zone_parser.parse(parsed_row.donation_date)
+        amount = parsed_row.amount
+
+        if @campaigns_hash.has_key?(campaign)
+          @campaigns_hash[campaign][:start_date] = [occurred_at, @campaigns_hash[campaign][:start_date]].min
+          @campaigns_hash[campaign][:end_date] = [occurred_at, @campaigns_hash[campaign][:end_date]].max
+          @campaigns_hash[campaign][:goal] = @campaigns_hash[campaign][:goal] + amount
+        else
+          @campaigns_hash[campaign] = {:start_date => occurred_at, :end_date => occurred_at, :goal => amount}
+        end
+      end
+    end
+
+  end
+
   def validate_amounts(parsed_row)
     if !parsed_row.unparsed_nongift_amount.blank? && parsed_row.nongift_amount > parsed_row.amount
       raise Import::RowError, "Non-deductible amount (#{parsed_row.unparsed_nongift_amount}) cannot be more than the total doantion amount (#{parsed_row.unparsed_amount})': #{parsed_row.row}"
@@ -39,6 +63,7 @@ class DonationsImport < Import
     raise Import::RowError, "Please include a first name, last name, email, or company name in this row: #{parsed_row.row}" unless attach_person(parsed_row).naming_details_available?
     raise Import::RowError, "Please include a payment method in this row: #{parsed_row.row}" if parsed_row.payment_method.blank?
     raise Import::RowError, "Donation type must be 'Monetary' or 'In-Kind': #{parsed_row.row}" unless GiveAction.subtypes.include? (parsed_row.donation_type)
+    raise Import::RowError, "No Date included in this row: #{parsed_row.row}" unless parsed_row.donation_date
     valid_date?   parsed_row.donation_date
     
     [:unparsed_amount, :unparsed_nongift_amount, :unparsed_deductible_amount].each do |amt|
@@ -48,37 +73,103 @@ class DonationsImport < Import
     validate_amounts(parsed_row)
     true
   end
-   
+
+  def create_campaign(parsed_row, params)
+    campaign_name = parsed_row.campaign
+    if campaign_name.present?
+      camp = self.organization.campaigns.where(:name => campaign_name).first_or_create do |campaign|
+        campaign.import = self
+        campaign.starts_at = @campaigns_hash[campaign_name] && @campaigns_hash[campaign_name][:start_date] ?
+            @campaigns_hash[campaign_name][:start_date] : time_zone_parser.now
+        campaign.ends_at = @campaigns_hash[campaign_name] && @campaigns_hash[campaign_name][:end_date] ?
+            @campaigns_hash[campaign_name][:end_date] : time_zone_parser.now
+        campaign.ends_at = nil if campaign.ends_at.to_s == campaign.starts_at.to_s
+        campaign.goal = @campaigns_hash[campaign_name] && @campaigns_hash[campaign_name][:goal] ?
+            @campaigns_hash[campaign_name][:goal] / 100 : 1000
+        campaign.status = 'active'
+      end
+      params[:campaign_id] = camp.id
+      camp
+    end
+  end
+
+  def create_appeal(parsed_row, campaign, params)
+    if parsed_row.appeal.present? && !campaign.nil?
+      a = campaign.appeals.where({:name => parsed_row.appeal, :organization_id => self.organization.id}).first_or_create do |appeal|
+        appeal.import = self
+        appeal.starts_at = campaign.starts_at
+        appeal.channel = 'email'
+        appeal.status = 'active'
+      end
+      params[:appeal_id] = a.id
+    end
+  end
+
+  def create_match_eligible(parsed_row, params)
+    matcher = parsed_row.match_eligible_matcher
+    eligible_amount = parsed_row.match_eligible_amount
+    if matcher.present?  && matcher.include?("@") && eligible_amount > 0 # todo validate email
+      matcher_person = Person.first_or_create({:email => matcher, :organization => self.organization}) do |p|
+        p.import = self
+      end
+
+      params[:match_eligible] = 'true'
+      params[:matcher] = matcher_person.id
+      params[:eligible_amount] = eligible_amount
+      params[:ratio] = parsed_row.match_eligible_ratio.to_f if parsed_row.match_eligible_ratio.to_f > 0
+      params[:commitment_date] = time_zone_parser.now.to_s
+    end
+  end
+
+  def create_soft_credit(parsed_row, params)
+    soft_credit_email = parsed_row.soft_credit_email
+    soft_credit_first_name = parsed_row.soft_credit_first_name
+    soft_credit_last_name = parsed_row.soft_credit_last_name
+    soft_credit_amount = parsed_row.soft_credit_amount
+
+    if soft_credit_email.present? && soft_credit_email.include?("@") && soft_credit_amount > 0
+      sc_person = Person.first_or_create({:email => soft_credit_email, :organization => self.organization}) do |p|
+        p.import = self
+        p.first_name = soft_credit_first_name
+        p.last_name = soft_credit_last_name
+      end
+      params[:soft_credit] = {-Time.now.to_i => {:person_id => sc_person.id, :amount => soft_credit_amount}}
+    end
+  end
+
   def create_contribution(parsed_row, person)
     Rails.logger.info("Processing Import [#{id}] DONATION_IMPORT: Creating contribution")
-    validate_amounts(parsed_row)
+    params = {}
+    params[:creator_id] = self.user.id
+    params[:person_id] = person.id
+
     amount              = parsed_row.amount
     deductible_amount   = parsed_row.unparsed_deductible_amount.blank?  ? amount - parsed_row.nongift_amount     : parsed_row.deductible_amount
     nongift_amount      = parsed_row.unparsed_nongift_amount.blank?     ? amount - deductible_amount             : parsed_row.nongift_amount
     
     occurred_at = parsed_row.donation_date.blank? ? time_zone_parser.now : time_zone_parser.parse(parsed_row.donation_date)
-    params = {}
+
     params[:subtype] = parsed_row.donation_type
-    params[:amount] = deductible_amount
+    params[:amount] = deductible_amount + nongift_amount
     params[:nongift_amount] = nongift_amount
     params[:payment_method] = parsed_row.payment_method
     
     params[:organization_id] = self.organization.id
     params[:occurred_at] = occurred_at.to_s
     params[:details] = "Imported by #{user.email} on  #{I18n.l self.created_at_local_to_organization, :format => :date}"
-    params[:person_id] = person.id
     params[:creator_id] = user.id
-    
+
+    params[:notes] = parsed_row.notes
+    params[:ack_sent_date] = parsed_row.ack_sent_date
+    params[:fiscal_year] = parsed_row.fiscal_year
+
+    campaign = create_campaign(parsed_row, params)
+    create_appeal(parsed_row, campaign, params)
+    create_match_eligible(parsed_row, params)
+    create_soft_credit(parsed_row, params)
+
     contribution = Contribution.new(params)
-    contribution.save(ImportedOrder) do |contribution|
-      contribution.order.import_id  = self.id
-      contribution.order.save
-      contribution.order.reload
-      contribution.action.import_id = self.id 
-      contribution.action.creator = self.user
-      contribution.action.details = "Donated #{number_as_cents contribution.order.total}"
-      contribution.action.save
-    end
+    contribution.save(ImportedOrder, self.id)
     contribution
   end
 end