artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/advanced_search_segment.rb

@@ -0,0 +1,12 @@
+class AdvancedSearchSegment < ActiveRecord::Base
+	belongs_to :advanced_search
+	belongs_to :organization
+
+	attr_accessible :name, :advanced_search_id, :organization_id
+
+	validates_presence_of :name
+
+  delegate :people, :to => :advanced_search
+  delegate :all_people, :to => :advanced_search
+
+end

data/app/models/appeal.rb

@@ -0,0 +1,106 @@
+class Appeal < ActiveRecord::Base
+  include OhNoes::Destroy
+
+  CHANNELS = {
+    :board_solicited          => 'Board Solicited',
+    :direct_mail              => 'Direct Mail',
+    :email                    => 'Email',
+    :in_person                => 'In Person',
+    :phone                    => 'Phone',
+    :proposal                 => 'Proposal (Grant)',
+    :sponsorship              => 'Sponsorship',
+    :other                    => 'Other',
+  }.with_indifferent_access
+  STATUSES = {
+    :active     => 'Active',
+    :inactive   => 'Inactive',
+  }.with_indifferent_access
+
+  belongs_to :campaign
+  belongs_to :organization
+  belongs_to :segment
+  belongs_to :import
+  has_many :donations
+
+  validates :campaign_id, :name, :starts_at, :channel, :status, :presence => true
+  validates :channel, :inclusion => CHANNELS.keys
+  validates :status, :inclusion => STATUSES.keys
+  validates_date :ends_at, :after => :starts_at, :allow_blank => true
+
+  before_save :check_delete_file
+  attr_accessor :remove_file_1, :remove_file_2, :remove_file_3
+
+  attr_accessible :name, :starts_at, :ends_at, :channel, :materials, :status, :segment_id, :notes,
+                  :file_1, :file_2, :file_3, :remove_file_1, :remove_file_2, :remove_file_3
+
+  FILE_FIELDS = [:file_1, :file_2, :file_3]
+  FILE_FIELDS.each do |field|
+    has_attached_file field,
+                      :storage        => :s3,
+                      :path           => "appeals/:id/#{field}/:filename",
+                      :bucket         => Rails.configuration.s3.bucket,
+                      :s3_protocol    => 'https',
+                      :s3_credentials => {
+                        :access_key_id      => Rails.configuration.s3.access_key_id,
+                        :secret_access_key  => Rails.configuration.s3.secret_access_key,
+                      }
+  end
+
+  default_scope lambda { order(:created_at).reverse_order }
+  scope :active, lambda { where(:status => 'active') }
+  scope :inactive, lambda { where(:status => 'inactive') }
+
+  def started?
+    self.starts_at <= DateTime.now
+  end
+
+  def ended?
+    self.ends_at.present? ? self.ends_at <= DateTime.now : false
+  end
+
+  def ongoing?
+    self.started? && !self.ended?
+  end
+
+  def duration
+    self.ends_at - self.starts_at
+  end
+
+  def time_remaining
+    self.ends_at.present? ? self.ends_at - DateTime.now : Float::INFINITY
+  end
+
+  def channel_name
+    CHANNELS[self.channel]
+  end
+
+
+  def response_rate
+    if segment
+      people = segment.people
+      people_ids = people.index_by(&:id).keys
+      heard_count = HearAction.where(:subject_type =>'Appeal').where(:subject_id => self.id).count(:person_id, :distinct =>  true)
+      orders_count = Order.joins('LEFT JOIN donations ON donations.order_id = orders.id').
+          where('donations.appeal_id' => self.id).
+          where(:person_id => people_ids).
+          count(:person_id, :distinct =>  true)
+
+      (((orders_count.to_f / heard_count.to_f) * 100).round(2)).to_s + '%' if heard_count.to_i > 0
+    end
+  end
+
+  def heard_action
+    HearAction.where(:subject_id =>self.id).where(:subject_type => 'Appeal').first
+  end
+
+  def destroyable?
+    self.donations.empty?
+  end
+
+  def check_delete_file
+    self.file_1 = nil if remove_file_1 == '1' && !file_1_updated_at_changed?
+    self.file_2 = nil if remove_file_2 == '1' && !file_2_updated_at_changed?
+    self.file_3 = nil if remove_file_3 == '1' && !file_3_updated_at_changed?
+  end
+
+end

data/app/models/box_office.rb

@@ -16,7 +16,7 @@ module BoxOffice
   
   class Order < ::Order  
     def self.location
-      "Box office"
+      "Box Office"
     end
   end
 end

data/app/models/budget_restriction.rb

@@ -0,0 +1,9 @@
+class BudgetRestriction < ActiveRecord::Base
+  attr_accessible :name
+
+  belongs_to :organization
+  has_many :campaigns
+
+  validates :name, :uniqueness => {:scope => :organization_id}
+
+end

data/app/models/campaign.rb

@@ -0,0 +1,141 @@
+class Campaign < ActiveRecord::Base
+  include OhNoes::Destroy
+
+  STATUSES = {
+    :active     => 'Active',
+    :inactive   => 'Inactive',
+  }.with_indifferent_access
+
+  belongs_to :organization
+  belongs_to :import
+  belongs_to :budget_restriction
+  has_many :appeals
+  has_many :donations
+
+  validates :organization_id, :name, :starts_at, :status, :goal, :presence => true
+  validates :goal, :numericality => { :only_integer => true, :greater_than_or_equal_to => 0, :message => "is not a number"}
+  validates :status, :inclusion => STATUSES.keys
+  validate :name_uniqueness
+  validate :date_sequence
+
+  attr_accessible :name, :starts_at, :ends_at, :status, :notes, :goal, :budget_restriction_id
+
+  default_scope lambda { order(:created_at).reverse_order }
+  scope :active, lambda { where(:status => 'active') }
+  scope :inactive, lambda { where(:status => 'inactive') }
+
+  def started?
+    self.starts_at <= DateTime.now
+  end
+
+  def ended?
+    self.ends_at.present? ? self.ends_at <= DateTime.now : false
+  end
+
+  def ongoing?
+    self.started? && !self.ended?
+  end
+
+  def duration
+    self.ends_at.present? ? (self.ends_at - self.starts_at).to_i : Float::INFINITY
+  end
+
+  def time_remaining
+    self.ends_at.present? ? (self.ends_at - DateTime.now).to_i : Float::INFINITY
+  end
+
+  def progress(donation_amount = nil)
+    progress = self.goal > 0 ? [(donation_amount || self.donations_to_date.to_f) / self.goal, 100.0].min : 0.0
+    (progress > 0.0 && progress < 1.0) ? 1.0 : progress
+  end
+
+  def pledges_progress(outstanding_pledges_to_date = nil)
+    pledges_progress = self.goal > 0 ? [(outstanding_pledges_to_date || self.pledges_outstanding_amount.to_f) / self.goal, 100.0].min : 0.0
+    (pledges_progress > 0.0 && pledges_progress < 1.0) ? 1.0 : pledges_progress
+  end
+
+  def appeals_donations
+    appeals_donations = {}
+
+    end_of_last_month = 0.seconds.ago.at_beginning_of_month - 1.second
+    beginnig_of_last_month = end_of_last_month.at_beginning_of_month
+    beginning_of_month = 0.seconds.ago.at_beginning_of_month
+    appeals.joins(:donations).select("appeals.*, " +
+      "SUM(IF(donations.created_at BETWEEN '#{beginnig_of_last_month}' AND '#{end_of_last_month}', donations.amount, 0)) last_month, " +
+      "SUM(IF(donations.created_at BETWEEN '#{beginning_of_month}' AND '#{0.seconds.ago}', donations.amount, 0)) this_month, " +
+      "SUM(IF(donations.created_at < '#{0.seconds.ago}', donations.amount, 0)) to_date")
+    .where("donations.pledge = ?", false)
+    .group("appeals.id").each do |appeal|
+      appeals_donations[appeal.id] = {:last_month => appeal.last_month.to_i, :this_month => appeal.this_month.to_i, :to_date => appeal.to_date.to_i}
+    end
+    appeals_donations
+  end
+
+  def donations_for_period(from, to = 0.seconds.ago)
+     self.donations.where('donations.created_at BETWEEN ? AND ?', from, to).where('donations.pledge'=> false).sum(:amount)
+  end
+
+  def donations_last_month
+    end_of_month = 0.seconds.ago.at_beginning_of_month - 1.second
+    donations_for_period(end_of_month.at_beginning_of_month, end_of_month)
+  end
+
+  def donations_this_month
+    beginning_of_month = 0.seconds.ago.at_beginning_of_month
+    donations_for_period(beginning_of_month)
+  end
+
+  def pledges_outstanding_amount
+    outstanding_pledges.sum('amount - received_amount').to_i
+  end
+
+  def outstanding_pledges
+    self.donations.where('donations.pledge'=> true).where('amount > received_amount')
+  end
+
+  def donors_count
+    Order.pledge(false).where('donations.campaign_id' => self.id).count('orders.person_id', :distinct =>  true)
+  end
+
+  def donations_to_date
+    self.donations.where('donations.created_at < ?', 0.seconds.ago).where('donations.pledge'=> false).sum(&:amount)
+  end
+
+  def top_orders(pledge, recent, limit)
+    Order.unscoped.includes(:person, :donation => :appeal)
+      .where('donations.campaign_id = ?', self.id)
+      .where('donations.pledge'=> pledge)
+      .where('orders.deleted_at IS NULL')
+      .order(recent ? 'donations.created_at DESC' : 'donations.amount DESC').limit(limit)
+  end
+
+  def goal=(num)
+    self[:goal] = num.to_s.gsub(',','')
+  end
+
+  def destroyable?
+    self.donations.empty?
+  end
+
+  private
+
+  def name_uniqueness
+    # We're using MySQL so we can afford not taking care of name case sensitivity
+    existing = self.class.where(:name => self.name)
+                         .where(:organization_id => self.organization_id)
+                         .where(:deleted_at => nil)
+
+    if existing.any? && existing[0].id != self.id
+      self.errors[:name] << [
+        '^Campaign name has already been taken',
+        'add the year to the name to differentiate between recurring campaigns'
+      ].join(' - ')
+    end
+  end
+
+  def date_sequence
+    if ends_at.present? && starts_at.present? && (ends_at.to_s == starts_at.to_s || ends_at.to_date < starts_at.to_date)
+      self.errors[:name] << '^End date must be after start date'
+    end
+  end
+end

data/app/models/cart.rb

@@ -7,7 +7,7 @@ class Cart < ActiveRecord::Base
   has_many :passes,       :after_add => :calculate_fees
   after_destroy :clear!
   before_validation :set_token
-  attr_accessor :special_instructions
+  attr_accessor :special_instructions, :donor_instructions
   attr_accessible :token, :reseller_id
 
   validates :token,
@@ -24,16 +24,33 @@ class Cart < ActiveRecord::Base
   belongs_to :applied_pass, :class_name => Pass
 
   state_machine do
-    state :started
-    state :approved
-    state :rejected
+    state :started, :enter => :cart_started
+    state :approved, :enter => :cart_approved
+    state :rejected, :enter => :cart_rejected
 
     event(:approve, :success => :record_sold_price) { transitions :from => [ :started, :rejected ], :to => :approved }
+    
+    #
+    # Currently the only thing rejecting carts is Ticket.unlock
+    #
     event(:reject)  { transitions :from => [ :started, :rejected ], :to => :rejected }
+    event(:restart) { transitions :from => [ :started, :rejected ], :to => :started }
   end
 
   delegate :empty?, :to => :items
 
+  def cart_started
+    Rails.logger.debug("CART [#{self.id}] started")
+  end
+
+  def cart_approved
+    Rails.logger.debug("CART [#{self.id}] approved")
+  end
+
+  def cart_rejected 
+    Rails.logger.debug("CART [#{self.id}] rejected")
+  end 
+
   #
   # Note that this does return Item objects. It returns Tickets, Donations, Memberships, etc...
   #
@@ -56,12 +73,14 @@ class Cart < ActiveRecord::Base
   end
 
   def clear!
+    Rails.logger.debug("clearing CART [#{self.id}]")
     clear_tickets
     clear_donations
     clear_memberships
     clear_passes
     self.discount = nil
     self.applied_pass = nil
+    self.restart!
     save
   end
   
@@ -211,6 +230,10 @@ class Cart < ActiveRecord::Base
     end
   end
 
+  def only_has?(collection)
+    (self.send(collection).length > 0) && (self.send(collection).length == self.items.length)
+  end
+
   def reset_prices_on_tickets
     transaction do
       tickets.each {|ticket| ticket.reset_price! }
@@ -235,6 +258,18 @@ class Cart < ActiveRecord::Base
     rel.where(:reseller_id => reseller_id) unless reseller_id.blank?
     rel.first
   end
+  
+  def tickets?
+    self.tickets.present?
+  end
+  
+  def ticket_cart_total
+    total = []
+    self.tickets.each do |ticket|
+      total << ticket.cart_price
+    end
+    total.sum
+  end
 
   private
 

data/app/models/chart.rb

@@ -2,7 +2,7 @@ class Chart < ActiveRecord::Base
   include Ticket::Foundry
   foundry :using => :sections, :with => lambda { { :venue => event.venue.name } }
   attr_accessor :skip_create_first_section
-  attr_accessible :name, :is_template, :event_id, :organization_id, :old_mongo_id, :sections_attributes, :ticket_types_attributes, :organization, :event, :skip_create_first_section
+  attr_accessible :name, :is_template, :event_id, :organization_id, :sections_attributes, :ticket_types_attributes, :organization, :event, :skip_create_first_section
 
   belongs_to :event
   belongs_to :organization
@@ -68,8 +68,8 @@ class Chart < ActiveRecord::Base
   # This is how they're submitted from the ticket types form
   #
   def update_attributes_from_params(params_hash = {})
-    update_attributes(params_hash)
     upgrade_event
+    update_attributes(params_hash)
   end
   
   #If this is a free event, and they've specified prices on this chart, then upgrade to a paid event

data/app/models/checkout.rb

@@ -6,13 +6,17 @@ class Checkout
   include Ext::Callbacks::Checkout
   include Ext::Preprocessor
 
-  attr_accessor :cart, :payment, :error, :notes
+  attr_accessor :cart, :payment, :error, :notes, :fafs_only, :fafs_success
   attr_reader :order, :person
 
   def self.for(cart, payment)
     cart.checkout_class.new(cart, payment)
   end
 
+  def checkout_id
+    @checkout_id ||= SecureRandom.hex(4)
+  end
+
   def message
     message = @error || @payment.errors.full_messages.to_sentence.downcase
     message = message.gsub('customer', 'contact info')
@@ -53,8 +57,39 @@ class Checkout
     true
   end
 
+  def process
+    begin
+      start
+      (rollback and return false) unless valid?
+      (rollback and return false) unless finish
+      cleanup
+      true
+    rescue Exception => e 
+      rollback
+      log "#{e.class.name}"
+      raise e
+    end
+  end
+
+  def start
+    log "starting"
+    log "processing tickets #{cart.tickets.collect(&:id)}"
+    Ticket.processing!(cart.tickets, cart)
+  end
+
+  def rollback
+    log "rolling back"
+    log "unprocessing tickets #{cart.tickets.collect(&:id)}"
+    Ticket.unprocessing!(cart.tickets, cart)
+  end
+
+  def cleanup
+    log "cleaning up"
+    log "unprocessing tickets #{cart.tickets.collect(&:id)}"
+    Ticket.unprocessing!(cart.tickets, cart)
+  end
+
   def finish
-    log "started"
     begin
       log "preprocess"
       if preprocess && pay
@@ -70,7 +105,9 @@ class Checkout
         end
       else
         log "authorization failed"
+        false
       end
+      true
     rescue Exception => e
       log "threw exception"
       log e
@@ -84,7 +121,7 @@ class Checkout
   end
 
   def log(message)
-    Rails.logger.info "CHECKOUT: cart [#{cart.id}] #{message}"
+    Rails.logger.info "CHECKOUT [#{checkout_id}]: cart [#{cart.id}] #{message}"
   end
 
   def pay
@@ -113,19 +150,24 @@ class Checkout
     "checkout"
   end
 
+  protected
+    def person_attributes
+      attributes = {}
+      attributes[:id]           = @customer.id unless @customer.id.nil?
+      attributes[:email]        = @customer.email
+      attributes[:first_name]   = @customer.first_name
+      attributes[:last_name]    = @customer.last_name   
+      attributes   
+    end
+
   private
     def create_sub_orders(order_timestamp)
       created_orders = []
       log("creating sub orders")
       log("Organizations in this cart [#{cart.organizations.collect(&:id)}]")
       cart.organizations.each do |organization|
-        attributes = {}
-        attributes[:id]           = @customer.id unless @customer.id.nil?
-        attributes[:email]        = @customer.email
-        attributes[:first_name]   = @customer.first_name
-        attributes[:last_name]    = @customer.last_name
-        attributes[:organization] = organization
-
+        attributes = person_attributes.merge({:organization => organization})
+        
         @person = Person.first_or_create(attributes)
         CheckoutProcessor.process(@person, @customer, Address.from_payment(payment), payment.payment_phone_number, organization.time_zone, checkout_name)
         @order = new_order(organization, order_timestamp, @person)
@@ -151,9 +193,11 @@ class Checkout
         order.organization                = organization
         order.created_at                  = order_timestamp
         order.person                      = @person
+        order.creator_id                  = @payment.benefactor.try(:id) if @payment.benefactor && payment.benefactor.try(:current_organization) == organization
         order.transaction_id              = @payment.transaction_id
         order.check_number                = @payment.check_number if payment.kind_of?(CheckPayment)
         order.special_instructions        = @cart.special_instructions
+        order.donor_instructions          = @cart.donor_instructions
         order.payment_method              = @payment.payment_method
         order.per_item_processing_charge  = @payment.per_item_processing_charge
         order.notes                       = @notes