artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/section.rb

@@ -3,7 +3,7 @@ class Section < ActiveRecord::Base
   attr_accessor :skip_create_first_ticket_type
   foundry :with => lambda { { :section_id => id, :count => capacity } }
 
-  attr_accessible :name, :capacity, :price, :chart_id, :old_mongo_id, :description, :ticket_types_attributes, :members
+  attr_accessible :name, :capacity, :price, :chart_id, :description, :ticket_types_attributes, :members
   delegate :show, :to => :chart
 
   has_many :ticket_types, :order => 'price DESC'
@@ -60,10 +60,12 @@ class Section < ActiveRecord::Base
     types << ticket_types.storefront
     unless member.nil?
 
-      #Add "unrestricted member" ticket_types that aren't tied to a particular membership type
-      types << ticket_types.members.select{|ticket_type| !ticket_type.member_ticket?} unless member.nil?
+      # Add ticket types that are visible to members but *do not* have a membership
+      # type assigned. This is a case where a producer wants to show a ticket type to all members
+      # but not restrict that ticket type to a particular set of members
+      types << ticket_types.members.select{|ticket_type| !ticket_type.member_ticket?}
 
-      #Now add member ticket_types that apply to this particular member
+      # Now add member ticket_types that apply to this particular member
       membership_type_ids = member.nil? ? [] : member.current_membership_types.collect(&:id)
       types << ticket_types.select{|ticket_type| ticket_type.members && membership_type_ids.include?(ticket_type.membership_type_id) }
     end

data/app/models/show.rb

@@ -6,7 +6,7 @@ class Show < ActiveRecord::Base
   include Ext::Integrations::Show
   include Ext::Uuid
 
-  attr_accessible :datetime, :event_id, :chart_id, :organization_id, :old_mongo_id, :cached_stats
+  attr_accessible :datetime, :event_id, :chart_id, :organization_id, :cached_stats
   store :cached_stats, :accessors => [ :capacity, :on_sale, :off_sale, :open, :sold, :comped, :local_datetime, :offset, :time_zone, :iana_time_zone ]
 
 
@@ -45,7 +45,9 @@ class Show < ActiveRecord::Base
 
   delegate :free?, :to => :event
 
-  state_machine do
+  ANY_SHOW_ID = "-1"
+
+  state_machine :auto_scopes => true do
 
     #pending and built are deprecated, left in only because we have shows in production which are built
     state :pending
@@ -75,8 +77,7 @@ class Show < ActiveRecord::Base
                   .where(:pass_type_id => pass.pass_type.id).first
 
     return false if epts.blank?
-
-    return !epts.excluded_shows.include?(self.id)
+    return !epts.excluded_shows.include?(self.id.to_s)
   end
 
   #
@@ -85,7 +86,15 @@ class Show < ActiveRecord::Base
   def refresh_stats
     tickets.reload
 
-    self.local_datetime = self.datetime_local_to_event.to_s unless self.event.nil?
+    #
+    # The upgrade to Ruby 2.1 left this serialization doing really funny things
+    # attempting to serialize this as a DateTime somehow lost time precision so 
+    # all shows would a date but 00:00:00 UTC for showtime
+    #
+    # Thus, we have no choice but to store this as a String and parse it everywhere
+    # that is is needed
+    #
+    self.local_datetime = self.datetime_local_to_unscoped_event.to_s unless self.event_id.nil?
 
     self.capacity = self.glance.available.capacity
     self.on_sale  = self.glance.available.on_sale
@@ -94,20 +103,20 @@ class Show < ActiveRecord::Base
     self.comped   = self.glance.comped.total
     self.open     = self.glance.available.open
 
-    unless self.event.time_zone.nil?
-      self.offset         = ActiveSupport::TimeZone.create(self.event.time_zone).parse(self.local_datetime).formatted_offset
+    if self.event_id.present? && self.unscoped_event.time_zone.present?
+      self.offset         = ActiveSupport::TimeZone.create(self.unscoped_event.time_zone).parse(self.local_datetime).formatted_offset
+      self.time_zone      = self.unscoped_event.time_zone
+      self.iana_time_zone = ActiveSupport::TimeZone::MAPPING[self.unscoped_event.time_zone]
     end
-    
-    self.time_zone      = self.event.time_zone
-    self.iana_time_zone = ActiveSupport::TimeZone::MAPPING[self.event.time_zone]
+
+    self.event.delay.refresh_stats unless self.event.nil?
 
     self.save(:validate => false)
-    self.event.delay.refresh_stats
     self.cached_stats
   end
 
   def parsed_local_datetime
-    @parsed_local_datetime = (DateTime.parse(self.local_datetime) rescue self.datetime_local_to_event)
+    @parsed_local_datetime = (DateTime.parse(self.local_datetime.to_s) rescue self.datetime_local_to_event)
   end
 
   def create_and_on_sale_tickets

data/app/models/show_validator.rb

@@ -0,0 +1,45 @@
+class ShowValidator
+  
+  attr_accessor :consumer, :params
+  
+  def initialize(consumer, params)
+    @consumer = consumer
+    @params   = params
+  end
+  
+  def validate(event)
+    if check_datetimes
+      consumer.datetime_error_and_redirect(event)
+    elsif check_charts
+      consumer.chart_error_and_redirect(event)
+    elsif check_ticket_types
+      consumer.ticket_type_error_and_redirect(event)
+    else
+      consumer.valid_show_succeed(params, event)
+    end
+  end
+  
+  def check_datetimes
+    if params['show']['datetime'].blank?
+      true
+    end
+  end
+  
+  def check_charts
+    if params['show']['chart'].blank? || params['show']['chart'].nil?
+      true
+    end
+  end
+  
+  def check_ticket_types
+    checker = false
+    params['show']['chart']['sections_attributes']['0']['ticket_types_attributes'].each_value do |inner_hash|
+      inner_hash.each do |key, value|
+        if key == 'name' && value == ''
+          checker = true
+        end
+      end
+    end
+    checker
+  end
+end

data/app/models/soft_credit.rb

@@ -0,0 +1,126 @@
+class SoftCredit < ActiveRecord::Base
+  attr_accessible :amount, :donation_id, :organization_id, :person_id
+  belongs_to :person
+  belongs_to :organization
+
+  after_save    :calculate_lifetime_value
+  after_destroy :calculate_lifetime_value
+
+
+  def self.update_soft_credits(db_soft_credits, curr_soft_credits, donation_id, organization_id)
+    new_soft_credits = db_soft_credits.empty? ? curr_soft_credits : []
+    updated_soft_credits = Set.new
+    deleted_soft_credits = {}
+
+    db_soft_credits.each do |db_sc|
+      deleted_soft_credits[db_sc.id] = db_sc if db_sc.id > 0 #mark temporary all as deleted
+      curr_soft_credits.each do |curr_sc|
+        deleted_soft_credits.delete(db_sc.id) if curr_sc.id == db_sc.id #remove from deleted list presented only
+        if curr_sc.id == db_sc.id && db_sc.amount != curr_sc.amount
+          db_sc.amount = curr_sc.amount
+          updated_soft_credits << db_sc # if amount is changed - mark as updated
+        elsif curr_sc.id < 0
+          new_soft_credits << curr_sc #all with negative id are new
+        end
+      end
+    end
+
+    new_soft_credits = new_soft_credits.uniq
+
+    save_all(new_soft_credits.uniq, donation_id, organization_id)
+    updated_soft_credits.each do |sc| #update existing records
+      sc.save!
+    end
+    SoftCredit.where(:id => deleted_soft_credits.keys.to_a()).destroy_all # destroy deleted records
+
+    {:new => new_soft_credits, :updated => updated_soft_credits, :deleted => deleted_soft_credits}
+  end
+
+  def self.save_all(new_soft_credits, donation_id, organization_id)
+    new_soft_credits.each do |new_sc|
+      next if new_sc.person_id.to_i <= 0
+      new_sc.id = nil if new_sc.id.to_i <= 0
+      new_sc.donation_id = donation_id
+      new_sc.organization_id = organization_id
+      new_sc.save!
+    end
+  end
+
+  def self.build_soft_credits(soft_credits_hash)
+    soft_credits = []
+    soft_credits_hash.each do |id, sc|
+      soft_credit = SoftCredit.new
+      soft_credit.id = id.to_i
+      soft_credit.person_id = sc[:person_id].to_i
+      soft_credit.amount = sc[:amount].to_i
+      soft_credits << soft_credit
+    end
+    soft_credits
+  end
+
+  def self.default_soft_credit
+    soft_credit = SoftCredit.new
+    soft_credit.id = -Time.now.to_i
+    soft_credit
+  end
+
+  def build_sc_action(contribution, order)
+    action = GiveAction.for_organization(contribution.organization)
+
+    action.person = Person.find(person_id)
+    action.subject = order
+    action.import_id = order.import_id
+    action.occurred_at = contribution.occurred_at
+    action.creator_id = contribution.creator_id
+    action.details = action_details(contribution)
+
+
+    action
+  end
+
+  def action_details(contribution)
+    donor = Person.find(contribution.person_id)
+    the_amount = amount.to_i > 0 ? amount * 100 : contribution.amount
+    details = Contribution.number_as_cents(the_amount)
+    details << ' for ' << contribution.campaign.name if contribution.campaign
+    details << ' (soft credit for gift from ' << donor.to_s << ')'
+    details
+  end
+
+  def calculate_lifetime_value
+    # async on person
+    self.person.calculate_lifetime_value
+  end
+
+  def self.update_sc_actions(contr, order, sc_hash)
+    new_soft_credits = sc_hash[:new]
+    updated_soft_credits = sc_hash[:updated]
+    deleted_soft_credits = sc_hash[:deleted]
+
+    new_soft_credits.each do |sc|
+      next if sc.person_id.to_i <= 0
+      action = sc.build_sc_action(contr, order)
+      action.save!
+    end
+
+    updated_soft_credits.each do |sc|
+      person = Person.find(sc.person_id)
+      action = person.actions.where(:subject_type => 'Order').where(:subject_id => order.id).first
+      action.update_attribute(:details, sc.action_details(contr))
+    end
+
+    deleted_soft_credits.each do |key, sc|
+      person = Person.find(sc.person_id)
+      action = person.actions.where(:subject_type => 'Order').where(:subject_id => order.id).first
+      action.destroy
+    end
+  end
+
+  def self.soft_credits_by(person)
+    soft_credits = SoftCredit.where(:person_id => person.id)
+    {:count => soft_credits.count, :amount => soft_credits.sum(:amount).to_i * 100}
+    # amount = SoftCredit.where(:person_id => person.id).sum(:amount).to_i
+    # amount * 100
+  end
+
+end

data/app/models/subscribed_list.rb

@@ -0,0 +1,52 @@
+class SubscribedList < ActiveRecord::Base
+  attr_accessor :sync, :single_optin
+
+  attr_accessible :list_id, :sync, :single_optin, :confirmed, :bounced
+
+  belongs_to :person
+  has_many :groupings, :class_name => "ListGrouping"
+
+  validates :list_id, :presence => true, :uniqueness => { :scope => :person_id }
+
+  after_create :push_create_to_mailchimp
+  before_destroy :push_destroy_to_mailchimp
+  after_save { person.solr_index! if person }
+  after_destroy { person.solr_index! if person }
+
+  delegate :organization, :to => :person
+
+  after_initialize do
+    self.sync = true if sync.nil?
+  end
+
+  def self.not_bounced
+    where(:bounced => false)
+  end
+
+  private
+
+  def mailchimp_kit
+    organization.kits.mailchimp
+  end
+
+  def push_create_to_mailchimp
+    return unless sync
+    job = MailchimpSyncJob.new(mailchimp_kit, {
+      :type => :person_subscribe,
+      :person_id => person_id,
+      :list_id => list_id,
+      :single_optin => single_optin,
+    })
+    Delayed::Job.enqueue(job, :queue => "mailchimp") if !mailchimp_kit.cancelled?
+  end
+
+  def push_destroy_to_mailchimp
+    return unless sync
+    job = MailchimpSyncJob.new(mailchimp_kit, {
+      :type => :person_unsubscribe,
+      :person_id => person_id,
+      :list_id => list_id,
+    })
+    Delayed::Job.enqueue(job, :queue => "mailchimp") if !mailchimp_kit.cancelled?
+  end
+end

data/app/models/suggested_household.rb

@@ -1,5 +1,7 @@
 class SuggestedHousehold < ActiveRecord::Base
-  attr_accessible :ids, :ignored
+  attr_accessible :ids, :ignored, :organization_id
+
+  belongs_to :organization
 
   def self.with_people(people)
     ids = people.map(&:id).sort.join(',')
@@ -14,11 +16,15 @@ class SuggestedHousehold < ActiveRecord::Base
   def self.find_or_create_with_people(people)
     ids = people.map(&:id).sort.join(',')
     matches = where(:ids => ids)
-    matches.first ? matches.first : SuggestedHousehold.create_with_people(people)
+    matches.first ? matches.first : create_with_people(people)
   end
 
   def individuals
     Individual.where(:id => ids.split(','))
   end
 
+  def ignore!
+    update_attributes(:ignored => true)
+  end
+
 end

data/app/models/ticket.rb

@@ -1,4 +1,4 @@
- class Ticket < ActiveRecord::Base
+class Ticket < ActiveRecord::Base
   include ActiveRecord::Transitions
   include Ext::Resellable::Ticket
   include Ext::Integrations::Ticket
@@ -23,12 +23,16 @@
   belongs_to :action, :foreign_key => "validated_action_id", :class_name => "GoAction"
 
   #
-  # This refs the ticket_type that the ticket was sold under, NOT an array of ticket types available
+  # This refs the ticket_type that the ticket was sold under, 
+  # NOT an array of ticket types available
   #
   belongs_to :ticket_type
-  
+
   has_many :items, :as => :product
 
+  after_save { buyer.solr_index! if buyer }
+  after_destroy { buyer.solr_index! if buyer }
+
   has_attached_file :qr_code, TICKET_QR_STORAGE
 
   delegate :url, :to => :qr_code, :prefix => true
@@ -48,8 +52,9 @@
 
   #Used when unlocking tickets. We don't want to unlocked sold or comped tickets.
   scope :uncommitted,   where("state != 'sold'").where("state != 'comped'")
+  scope :sold_or_comped, where(:state => [:sold, :comped])
 
-  state_machine do
+  state_machine :auto_scopes => true do
     state :off_sale
     state :on_sale
     state :sold
@@ -64,6 +69,22 @@
     event(:return_off_sale)                           { transitions :from => [ :comped, :sold ],        :to => :off_sale  }
   end
 
+  searchable do
+    integer :buyer_id, stored: true
+    integer :organization_id
+    integer :show_id
+    integer :event_id do
+      show.nil? ? nil : show.event_id
+    end
+    date :show_date do
+      (show.nil? || show.event.nil?) ? nil : show.datetime_local_to_event
+    end
+    integer :ticket_type_id do
+      ticket_type.id unless ticket_type.nil?
+    end
+  end
+  include Ext::DelayedIndexing
+
   def datetime
     show.datetime_local_to_event
   end
@@ -76,7 +97,7 @@
   end
 
   #
-  # This is here so that Item.for can add tickets. 
+  # This is here so that Item.for can add tickets.
   # Ticket is composing what it means to be turned into an item
   #
   def price
@@ -84,7 +105,7 @@
   end
 
   def as_json(options = {})
-    super(options).merge!({:ticket_type => ticket_type}).except!("section_id", "buyer_id", "show_id", "ticket_type_id", "cart_id", "discount_id", "organization_id", "old_mongo_id")
+    super(options).merge!({:ticket_type => ticket_type}).except!("section_id", "buyer_id", "show_id", "ticket_type_id", "cart_id", "discount_id", "organization_id")
   end
 
   def self.unsold
@@ -123,13 +144,13 @@
   def settled_item
     @settled_item ||= items.select(&:settled?).first
   end
-  
+
   def sold_item
     items.select(&:purchased?).first ||
     items.select(&:settled?).first ||
     items.select(&:comped?).first
   end
-  
+
   def special_instructions
     sold_item.try(:order).try(:special_instructions)
   end
@@ -168,6 +189,10 @@
     !expired?
   end
 
+  def convertable?
+    !expired?
+  end
+
   def committed?
     sold? or comped?
   end
@@ -207,12 +232,12 @@
     quantity.times do
       new_tickets << build_one(show, section, quantity, on_sale)
     end
-    
+
     result = Ticket.import(new_tickets)
     show.refresh_stats
     result
   end
-  
+
   #
   # This method does not refresh show stats
   # Callers should do that manually with show.delay.refresh_stats