artfully_ose 1.0.0.rc4 → 1.1.0.rc1

data/app/models/kits/reseller_kit.rb

@@ -1,6 +1,6 @@
 class ResellerKit < Kit
 
-  acts_as_kit :with_approval => true do
+  acts_as_kit :with_approval => true, :admin_only => true do
     activate :unless => :no_owner?
     approve :unless => :no_bank_account?
 
@@ -14,7 +14,7 @@ class ResellerKit < Kit
   end
 
   def pitch
-    "Resell tickets"
+    "Resell tickets from other producers on your own website."
   end
 
   def no_owner?

data/app/models/kits/sponsored_donation_kit.rb

@@ -27,11 +27,11 @@ class SponsoredDonationKit < Kit
   end
   
   def pitch
-    "Contact support@artful.ly to learn about Fiscal Sponsorship through Fractured Atlas for your organization"
+    "Contact support@fracturedatlas.org to learn about Fiscal Sponsorship through Fractured Atlas."
   end
 
   def connected?
-    errors.add(:requirements, "You need to connect to your Fractured Atlas Membership to active this kit") unless organization.connected?
+    errors.add(:requirements, "You need to connect to your Fractured Atlas Membership to active this kit.") unless organization.connected?
     organization.connected?
   end
 

data/app/models/orders/application_order.rb

@@ -1,5 +1,7 @@
 class ApplicationOrder < Order
-  def location
+  include Unrefundable
+  
+  def self.location
     "Artful.ly"
   end
 end

data/app/models/orders/comp_order.rb

@@ -1,5 +1,18 @@
-class CompOrder < Order  
-  def location
+class CompOrder < Order
+  include Unrefundable
+    
+  def self.location
     "Artful.ly"
   end
+  
+  def initialize
+    super
+    self.payment_method = ::CompPayment.payment_method
+  end
+  
+  def sell_tickets
+    all_tickets.each do |item|
+      item.product.comp_to(self.person, self.created_at)
+    end
+  end
 end

data/app/models/orders/exchange_order.rb

@@ -0,0 +1,8 @@
+class ExchangeOrder < Order 
+  def self.location
+    "Artful.ly"
+  end
+  
+  def sell_tickets
+ 	end
+end

data/app/models/orders/imported_order.rb

@@ -0,0 +1,7 @@
+class ImportedOrder < ::Order
+  include Unrefundable
+  
+  def location
+    "Artful.ly"
+  end
+end

data/app/models/orders/order.rb

@@ -3,18 +3,23 @@
 class Order < ActiveRecord::Base
   include ActionView::Helpers::NumberHelper
   include ActionView::Helpers::TextHelper
-  include ArtfullyOseHelper
   include Ext::Integrations::Order
+  include OhNoes::Destroy
+  include ArtfullyOseHelper
   
   #This is a lambda used to by the items to calculate their net
   attr_accessor :per_item_processing_charge
 
+  attr_accessible :person_id, :organization_id, :person, :organization, :details
+
   belongs_to :person
   belongs_to :organization
+  belongs_to :import
   belongs_to :parent, :class_name => "Order", :foreign_key => "parent_id"
+  belongs_to :gateway_transaction, :primary_key => :transaction_id, :foreign_key => :transaction_id
   has_many :children, :class_name => "Order", :foreign_key => "parent_id"
-  has_many :items
-  has_many :actions, :foreign_key => "subject_id"
+  has_many :items, :dependent => :destroy
+  has_many :actions, :foreign_key => "subject_id", :dependent => :destroy
 
   attr_accessor :skip_actions
 
@@ -24,16 +29,57 @@ class Order < ActiveRecord::Base
   validates_presence_of :person_id
   validates_presence_of :organization_id
 
+  # Both of these are handle_asynchronously
   after_create :create_purchase_action, :unless => :skip_actions
   after_create :create_donation_actions, :unless => :skip_actions
 
+  after_create :sell_tickets
+
   default_scope :order => 'orders.created_at DESC'
   scope :before, lambda { |time| where("orders.created_at < ?", time) }
   scope :after,  lambda { |time| where("orders.created_at > ?", time) }
   scope :imported, where("fa_id IS NOT NULL")
   scope :not_imported, where("fa_id IS NULL")
+  scope :csv_imported, where("import_id IS NOT NULL")
+  scope :csv_not_imported, where("import_id IS NULL")
   scope :artfully, where("transaction_id IS NOT NULL")
 
+  searchable do
+    text :details, :id, :type, :location, :transaction_id, :payment_method, :special_instructions
+
+    [:first_name, :last_name, :email].each do |person_field|
+      text person_field do
+        person.send(person_field) unless person.nil?
+      end
+    end
+
+    text :organization_id do
+      organization.id
+    end
+
+    text :organization_name do
+      organization.name
+    end
+
+    text :event_name do
+      items.map{ |item| item.show.event.name unless item.show.nil? }
+    end
+
+    string :details, :id, :type, :location, :transaction_id, :payment_method, :special_instructions
+    string :organization_id do
+      organization.id
+    end
+
+    string :organization_name do
+      organization.name
+    end
+
+    string :event_name, :multiple => true do
+      items.map{ |item| item.show.event.name unless item.show.nil? }
+    end
+  end
+  include Ext::DelayedIndexing
+
   def self.in_range(start, stop, organization_id = nil)
     query = after(start).before(stop).includes(:items, :person, :organization).order("created_at DESC")
     if organization_id.present?
@@ -48,6 +94,10 @@ class Order < ActiveRecord::Base
   end
   
   def location
+    self.class.location
+  end
+  
+  def self.location
     ""
   end
 
@@ -58,13 +108,13 @@ class Order < ActiveRecord::Base
   def nongift_amount
     all_items.inject(0) {|sum, item| sum + item.nongift_amount.to_i }
   end
-
-  def tickets
-    items.select(&:ticket?)
+  
+  def destroyable?
+    ( (type.eql? "ApplicationOrder") || (type.eql? "ImportedOrder") ) && !is_fafs? && !artfully? && has_single_donation?
   end
-
-  def donations
-    items.select(&:donation?)
+  
+  def editable?
+    ( (type.eql? "ApplicationOrder") || (type.eql? "ImportedOrder") ) && !is_fafs? && !artfully? && has_single_donation? 
   end
 
   def for_organization(org)
@@ -76,12 +126,12 @@ class Order < ActiveRecord::Base
   end
 
   def payment
-    AthenaPayment.new(:transaction_id => transaction_id)
+    CreditCardPayment.new(:transaction_id => transaction_id)
   end
 
-  def record_exchange!
-    items.each do |item|
-      item.to_exchange!
+  def record_exchange!(exchanged_items)
+    items.each_with_index do |item, index|
+      item.to_exchange! exchanged_items[index]
     end
   end
 
@@ -93,15 +143,30 @@ class Order < ActiveRecord::Base
     all_items.select(&:ticket?)
   end
 
+  #TODO: Undupe these methods
+  def tickets
+    items.select(&:ticket?)
+  end
+
   def all_donations
     all_items.select(&:donation?)
   end
 
+  def donations
+    items.select(&:donation?)
+  end
+  #End dupes
+  
+  def has_single_donation?
+    (donations.size == 1) && tickets.empty?
+  end
+
   def settleable_donations
     all_donations.reject(&:modified?)
   end
 
   def refundable_items
+    return [] unless Payment.create(payment_method).refundable?
     items.select(&:refundable?)
   end
 
@@ -109,6 +174,10 @@ class Order < ActiveRecord::Base
     items.select(&:exchangeable?)
   end
 
+  def returnable_items
+    items.select { |i| i.returnable? and i.comped? and not i.refundable? }
+  end
+
   def num_tickets
     all_tickets.size
   end
@@ -122,11 +191,22 @@ class Order < ActiveRecord::Base
   end
 
   def sum_donations
-    all_donations.collect{|item| item.price.to_i}.sum
+    all_donations.collect{|item| item.total_price.to_i}.sum
+  end
+
+  #
+  # Will return an array of all discount codes on all items on this order
+  #
+  def discounts_used
+    items.map{|i| i.discount.try(:code)}.reject(&:blank?).uniq
   end
 
   def ticket_details
-    pluralize(num_tickets, "ticket") + " to " + all_tickets.first.show.event.name
+    discount_string = ""
+    unless discounts_used.empty?
+      discount_string = ", used #{'discount'.pluralize(discounts_used.length)} " + discounts_used.join(",")
+    end
+    Ticket.to_sentence(self.tickets.map(&:product)) + discount_string
   end
   
   def to_comp!
@@ -141,16 +221,11 @@ class Order < ActiveRecord::Base
 
   def donation_details
     if is_fafs?
-      o = Organization.find(organization_id)
-      "#{number_as_cents sum_donations} donation via Fractured Atlas for the benefit of #{o.fiscally_sponsored_project.name}"
+      "#{number_as_cents sum_donations} donation made through Fractured Atlas"
     else
       "#{number_as_cents sum_donations} donation"
     end
   end
-
-  def returnable_items
-    items.select { |i| i.returnable? and not i.refundable? }
-  end
   
   def ticket_summary
     summary = TicketSummary.new
@@ -161,46 +236,84 @@ class Order < ActiveRecord::Base
   end
 
   def credit?
-    payment_method.eql? 'Credit card'
+    payment_method.eql? CreditCardPayment.payment_method
+  end
+
+  def cash?
+    payment_method.eql? CashPayment.payment_method
+  end
+
+  def original_order
+    if self.parent.nil?
+      return self
+    else
+      return self.parent.original_order
+    end
+  end
+
+  #
+  # If this order has no transaction_id, run up the parent chain until we hit one
+  # This is needed for exchanges that ultimately need to be refunded
+  #
+  def transaction_id
+    read_attribute(:transaction_id) || self.parent.try(:transaction_id)
+  end
+  
+  def sell_tickets
+    all_tickets.each do |item|
+      item.product.sell_to(self.person, self.created_at)
+    end
   end
   
   def time_zone
     "Eastern Time (US & Canada)"
   end
 
-  private
+  def contact_email
+    items.try(:first).try(:show).try(:event).try(:contact_email)
+  end
 
-    #this used to do more.  Now it only does this
-    def merge_and_sort_items
-      items
+  def create_donation_actions
+    items.select(&:donation?).collect do |item|
+      action                    = GiveAction.new
+      action.person             = person
+      action.subject            = self
+      action.organization_id    = organization.id
+      action.details            = donation_details
+      action.occurred_at        = created_at
+      action.subtype            = "Monetary"
+      action.save!
+      action
+    end
+  end
+  handle_asynchronously :create_donation_actions
+
+  def create_purchase_action
+    unless all_tickets.empty?
+      action                  = purchase_action_class.new
+      action.person           = person
+      action.subject          = self
+      action.organization     = organization
+      action.details          = ticket_details
+      action.occurred_at      = created_at
+
+      #Weird, but Rails can't initialize these so the subtype is hardcoded in the model
+      action.subtype          = action.subtype
+      action.import           = self.import if self.import
+      action.save!
+      action
     end
+  end
+  handle_asynchronously :create_purchase_action
 
-    def create_purchase_action
-      unless all_tickets.empty?
-        action                  = GetAction.new
-        action.person           = person
-        action.subject          = self
-        action.organization_id  = organization.id
-        action.details          = ticket_details
-        action.occurred_at      = created_at
-        action.subtype          = "Purchase"
+  def purchase_action_class
+    GetAction
+  end
 
-        action.save!
-        action
-      end
-    end
+  private
 
-    def create_donation_actions
-      items.select(&:donation?).collect do |item|
-        action                    = GiveAction.new
-        action.person             = person
-        action.subject            = self
-        action.organization_id    = organization.id
-        action.details            = donation_details
-        action.occurred_at        = created_at
-        action.subtype            = "Donation"
-        action.save!
-        action
-      end
+    #this used to do more.  Now it only does this
+    def merge_and_sort_items
+      items
     end
 end

data/app/models/orders/refund_order.rb

@@ -1,5 +1,18 @@
 class RefundOrder < Order
-  def location
+  include Unrefundable
+
+  def self.location
     "Artful.ly"
   end
+  
+  def sell_tickets
+  end
+
+  def purchase_action_class
+    RefundAction
+  end
+
+  def ticket_details
+    "received refund for " + pluralize(num_tickets, "ticket")
+  end
 end

data/app/models/orders/unrefundable.rb

@@ -0,0 +1,5 @@
+module Unrefundable
+  def refundable_items
+    []
+  end
+end

data/app/models/orders/web_order.rb

@@ -1,5 +1,5 @@
 class WebOrder < Order
-  def location
+  def self.location
     "Web"
   end
 end

data/app/models/organization.rb

@@ -3,12 +3,13 @@ class Organization < ActiveRecord::Base
   include Ext::Resellable::Organization
   include Ext::Integrations::Organization
   
-  attr_accessible :name, :time_zone
+  attr_accessible :name, :time_zone, :ein, :legal_organization_name, :email, :receive_daily_sales_report
   
   has_many :events
   has_many :charts
   has_many :shows
   has_many :tickets
+  has_many :discounts
 
   has_many :people
   has_many :segments
@@ -23,10 +24,12 @@ class Organization < ActiveRecord::Base
 
   has_many :imports
 
-  validates_presence_of :name
+  validates_presence_of :name, :email
   validates :ein, :presence => true, :if => :updating_tax_info
   validates :legal_organization_name, :presence => true, :if => :updating_tax_info
 
+  scope :receiving_sales_email, where(:receive_daily_sales_report => true)
+
   #
   # We aren't interested in FAFS donations, so override lifetime_orders
   # to only include Artfully orders  see: Valuation::LifetimeValue
@@ -35,6 +38,33 @@ class Organization < ActiveRecord::Base
     orders.where('transaction_id is not null')
   end
 
+  #
+  # Returns Tag objects.  For an array of tag strings, call unique_tag_strings_for
+  #
+  # This has been supersceded by tags_on and tag_counts_on in acts_as_taggable_on
+  # But those methods have not been added to a release yet.
+  #
+  def tags_for(tagged_association)
+    
+    #Yak
+    begin
+      self.send(tagged_association.to_sym)
+    rescue NoMethodError
+      raise NoMethodError, "No tagged has_many association found for #{tagged_association.to_sym}"
+    end
+
+    table_name = Kernel.const_get(tagged_association.to_s.classify).table_name
+    
+    ActsAsTaggableOn::Tag.joins("INNER JOIN taggings ON tags.id = taggings.tag_id")
+                         .joins("INNER JOIN #{table_name} ON #{table_name}.id = taggings.taggable_id")
+                         .joins("INNER JOIN organizations ON organizations.id = #{table_name}.organization_id")
+                         .where("organizations.id = ?", self.id)
+  end
+
+  def unique_tag_strings_for(tagged_association)
+    self.tags_for(tagged_association).all.map(&:name).uniq
+  end
+
   def owner
     users.first
   end
@@ -53,7 +83,8 @@ class Organization < ActiveRecord::Base
     @updating_tax_info = true
     update_attributes({
       :ein => params[:ein],
-      :legal_organization_name => params[:legal_organization_name]
+      :legal_organization_name => params[:legal_organization_name],
+      :email => params[:email]
     })
   end
 
@@ -62,7 +93,7 @@ class Organization < ActiveRecord::Base
   end
 
   def available_kits
-    Kit.pad_with_new_kits(kits).reject{ |kit| kit.type == "ResellerKit" }
+    Kit.pad_with_new_kits(kits)
   end
 
   def authorization_hash
@@ -72,11 +103,11 @@ class Organization < ActiveRecord::Base
   end
 
   def donations
-    Item.joins(:order).where(:product_type => "Donation", :orders => { :organization_id => id })
+    Item.includes(:order => [:person => :address]).where(:product_type => "Donation", :orders => { :organization_id => id })
   end
 
   def ticket_sales
-    Item.joins(:order).where(:product_type => "Ticket", :orders => { :organization_id => id })
+    Item.includes(:show, :order => [:person => :address]).where(:product_type => "Ticket", :orders => { :organization_id => id })
   end
 
   def has_kit?(name)
@@ -90,7 +121,7 @@ class Organization < ActiveRecord::Base
   private
 
     def check_for_duplicates(kit)
-      raise Kit::DuplicateError if kits.where(:type => kit.type).any?
+      raise Kit::DuplicateError if kits.find{|k| k.type == kit.type}
     end
 
     def donation_type