artfully_ose 1.1.0 → 1.2.0.alpha.1

data/app/models/imports/memberships_import.rb

@@ -0,0 +1,43 @@
+class MembershipsImport < Import
+  include Imports::Rollback
+  include Imports::Validations
+  
+  def kind
+    "memberships"
+  end
+  
+  def row_valid?(parsed_row)
+    raise Import::RowError, "No Amount included in this row: #{parsed_row.row}" if parsed_row.unparsed_amount.blank?
+    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?
+    valid_amount? parsed_row.unparsed_amount      unless parsed_row.unparsed_amount.blank?
+    valid_date?   parsed_row.order_date           unless parsed_row.order_date.blank?
+    true
+  end
+  
+  def process(parsed_row)
+    row_valid?(parsed_row)
+    membership_type        = create_membership_type(parsed_row)
+    person                 = create_person(parsed_row)
+    order                  = create_order(parsed_row, person, membership_type)
+    actions                = create_actions(parsed_row, person, memberships_type)
+  end
+
+  def create_membership_type(parsed_row)
+    membership_type = self.organization.membership_types.build({
+      :name => parsed_row.membership_name
+    })
+    membership_type.plan = parsed_row.membership_plan
+    membership_type
+  end
+
+  def create_order(parsed_row, person, membership_type)
+    #get order from hash
+    # for 0 to parsed_row.number_of_memberships
+         # create an item for this membership_type
+    #add the item to the order
+    #save the order
+    #update get_action
+    #hash order by order key (person, membership_type, payment_method)
+  end
+end

data/app/models/imports/people_import.rb

@@ -3,21 +3,43 @@ class PeopleImport < Import
     "people"
   end
   
-  def rollback 
+  def rollback
     self.people.destroy_all
   end
-  
+
+  def recallable?
+    true if self.status == "imported"
+  end
+
+  def recall
+    raise "Can't recall this import" unless recallable?
+    self.import_messages.destroy_all
+    self.recalling!
+
+    no_errors = true
+    self.people.each do |person|
+      if person.destroyable?
+        person.destroy
+      else
+        self.message(nil, nil, person, "#{person} had existing actions or orders, and wasn't able to be recalled.")
+        no_errors = false
+      end
+    end
+
+    self.recalled!
+    no_errors
+  end
+
   def process(parsed_row)
-    person      = create_person(parsed_row)
+    create_person(parsed_row)
   end
   
   def row_valid?(parsed_row)
-    person = attach_person(parsed_row)
-    
-    #We're doing this here because the error message for person_info is very bad
-    raise Import::RowError, "Please include a first name, last name, or email in this row: #{parsed_row.row}" unless attach_person(parsed_row).person_info
+    #We're doing this here because the error message for naming_details_available? is very bad
+    raise Import::RowError, "Please include a first name, last name, or email in this row: #{parsed_row.row}" unless attach_person(parsed_row).naming_details_available?
     
-    return (person.valid? ? true : error(parsed_row, person))
+    #We're bypassing the valid? check that used to be here because we're allowing dupe emails (they get merged later)
+    true
   end
   
   def error(parsed_row, person)
@@ -28,14 +50,20 @@ class PeopleImport < Import
   end
   
   def create_person(parsed_row)
-    Rails.logger.debug("PEOPLE_IMPORT: Importing person")
-    person = attach_person(parsed_row)
-    Rails.logger.debug("PEOPLE_IMPORT: Attached #{person.inspect}")
-    if !person.save
-      Rails.logger.debug("PEOPLE_IMPORT: Save failed")
-      Rails.logger.debug("PEOPLE_IMPORT: ERROR'D #{person.errors.full_messages.join(", ")}")
-      error(parsed_row, person)
-    end 
-    person  
+    new_person = attach_person(parsed_row)
+
+    existing_person = Person.first_or_initialize( {:email => new_person.email, :organization => self.organization} ) do |p|
+      p.import = self
+      p.type = new_person.type
+      p.subtype = new_person.subtype
+    end
+    message(nil, parsed_row, existing_person, "#{existing_person.email} exists. Will merge records.") unless existing_person.new_record?
+
+    existing_person.update_from_import(new_person)
+    existing_person.skip_commit = true
+    if !existing_person.save
+      error(parsed_row, existing_person)
+    end
+    existing_person  
   end
 end

data/app/models/imports/rollback.rb

@@ -4,8 +4,13 @@ module Imports
       Order.where(:import_id => self.id).where(:organization_id => self.organization.id).all.each {|o| o.destroy(:with_prejudice => true)}
     end
   
-    def rollback_people
-      Person.where(:import_id => self.id).where(:organization_id => self.organization.id).all.each {|p| p.destroy}
+    def rollback_people 
+      Rails.logger.debug "ROLLING BACK PEOPLE"
+      Person.where(:import_id => self.id).where(:organization_id => self.organization.id).all.each do |p|
+        Rails.logger.debug "Destroying [#{p.id}]"
+        result = p.destroy(:with_prejudice => true)
+        Rails.logger.debug result
+      end
     end
   end
 end

data/app/models/imports/status.rb

@@ -37,6 +37,14 @@ module Imports
       self.update_column(:status, "imported")
     end
 
+    def recalling!
+      self.update_column(:status, "recalling")
+    end
+
+    def recalled!
+      self.update_column(:status, "recalled")
+    end
+
     def failed!
       self.update_column(:status, "failed")
     end

data/app/models/individual.rb

@@ -0,0 +1,20 @@
+class Individual < Person
+
+  after_destroy { |record| Delayed::Job.enqueue(CleanupSuggestedHouseholdsJob.new(record.id), :queue => :suggested_households) }
+
+  def to_s
+    if first_name.present? || last_name.present?
+      [salutation, first_name, middle_name, last_name, suffix].reject(&:blank?).join(" ")
+    elsif email.present?
+      email.to_s
+    elsif id.present?
+      "No Name ##{id}"
+    else
+      "No Name"
+    end
+  end
+
+  def naming_details_available?
+    first_name.present? || last_name.present? || email.present?
+  end
+end

data/app/models/item.rb

@@ -12,6 +12,7 @@ class Item < ActiveRecord::Base
   belongs_to :reseller_order, :class_name => "Reseller::Order"
   belongs_to :product, :polymorphic => true
   belongs_to :discount
+  belongs_to :pass
 
   attr_accessible :order_id, :product_type, :state, :price, :realized_price, :net, :nongift_amount
   
@@ -19,45 +20,16 @@ class Item < ActiveRecord::Base
   attr_accessor :per_item_processing_charge
 
   validates_presence_of :product_type, :price, :realized_price, :net
-  validates_inclusion_of :product_type, :in => %( Ticket Donation )
+  validates_inclusion_of :product_type, :in => %( Ticket Donation Membership Pass)
 
-  scope :donation, where(:product_type => "Donation")
+  scope :donation,    where(:product_type => 'Donation')
+  scope :membership,  where(:product_type => 'Membership')
+  scope :ticket,      where(:product_type => 'Ticket')
 
   scope :imported, joins(:order).merge(Order.imported)
   scope :not_imported, joins(:order).merge(Order.not_imported)
 
-  comma :donation do
-    order("Email")                          { |order| order.person.email if order.person }
-    order("First Name")                     { |order| order.person.first_name if order.person }
-    order("Last Name")                      { |order| order.person.last_name if order.person }
-    order("Company Name")                   { |order| order.person.company_name if order.person }
-    order("Address1")                       { |order| order.person.address.address1 if (order.person && order.person.address) }
-    order("Address2")                       { |order| order.person.address.address2 if (order.person && order.person.address) }
-    order("City")                           { |order| order.person.address.city if (order.person && order.person.address) }
-    order("State")                          { |order| order.person.address.state if (order.person && order.person.address) }
-    order("Zip")                            { |order| order.person.address.zip if (order.person && order.person.address) }
-    order("Date")                           { |order| order.created_at }
-    order("Payment Method")                 { |order| order.payment_method }
-    order("Donation Type")                  { |order| order.actions.where(:type => "GiveAction").first.try(:subtype) }
-    price("Deductible Amount")              { |cents| (cents / 100.00) if cents }
-    nongift_amount("Non-Deductible Amount") { |cents| (cents / 100.00) if cents }
-  end
-
-  comma :ticket_sale do
-    order("Date of Purchase")               { |order| order.created_at }
-    order("Email")                          { |order| order.person.email if order.person }
-    order("First Name")                     { |order| order.person.first_name if order.person }
-    order("Last Name")                      { |order| order.person.last_name if order.person }
-    order("Address1")                       { |order| order.person.address.address1 if (order.person && order.person.address) }
-    order("Address2")                       { |order| order.person.address.address2 if (order.person && order.person.address) }
-    order("City")                           { |order| order.person.address.city if (order.person && order.person.address) }
-    order("State")                          { |order| order.person.address.state if (order.person && order.person.address) }
-    order("Zip")                            { |order| order.person.address.zip if (order.person && order.person.address) }
-    show("Performance Title")               { |show| show.event.name if show }
-    show("Performance Date-Time")           { |show| show.datetime_local_to_event if show }
-    price("Ticket Price")                   { |cents| number_to_currency(cents.to_f/100) if cents }
-    order("Special Instructions")           { |order| order.special_instructions }
-  end
+  #If you're exporting ticket sales or donations, use ItemView
 
   def ticket?
     product_type == "Ticket"
@@ -67,6 +39,27 @@ class Item < ActiveRecord::Base
     product_type == "Donation"
   end
 
+  def membership?
+    product_type == "Membership"
+  end
+
+  def pass?
+    product_type == "Pass"
+  end
+
+  def self.donations_by(person)
+    Item.donation.joins(:order).where('orders.person_id' => person.id)
+  end
+
+  #
+  # If the product that this item points to (a ticket, for instance) gets refunded or returned
+  # then re-sold to someone else, this item will still show up on the original purchaser's 
+  # action feed
+  #
+  def order_summary_description
+    dead? ? self.state.capitalize : "#{product.order_summary_description}"
+  end
+
   #
   # Donations stored in the FA DB are stored like so:
   # $100 sent
@@ -78,7 +71,11 @@ class Item < ActiveRecord::Base
   # and the "total_price" is the amount that was transacted (amount + nongift)
   #
   def total_price
-    price + (nongift_amount.nil? ? 0 : nongift_amount.to_i)  
+    price + (nongift_amount.nil? ? 0 : nongift_amount.to_i)
+  end
+
+  def self.total_price_sql_sum
+    "price + nongift_amount"
   end
 
   #
@@ -104,7 +101,8 @@ class Item < ActiveRecord::Base
   def product=(product)
     set_product_details_from product
     set_prices_from product
-    set_discount_from product if product.respond_to? :discount
+    set_discount_from product
+    set_pass_from product
     set_show_from product if product.respond_to? :show_id
     self.state = "purchased"
     self.product_id = if product then product.id end
@@ -118,15 +116,15 @@ class Item < ActiveRecord::Base
   end
 
   def refundable?
-    (not settlement_issued?) and product and product.refundable?
+    (not settlement_issued?) and (not dead?) and product and product.refundable?
   end
 
   def exchangeable?
-    (not settlement_issued?) and product and product.exchangeable?
+    (not settlement_issued?) and (not dead?) and product and product.exchangeable?
   end
 
   def returnable?
-    product and product.returnable?
+    (not dead?) and product and product.returnable?
   end
 
   #
@@ -150,6 +148,7 @@ class Item < ActiveRecord::Base
       item.price            = item.price.to_i * -1
       item.realized_price   = item.realized_price.to_i * -1
       item.net              = item.net.to_i * -1
+      item.service_fee      = item.service_fee.to_i * -1
       item.state            = "refund"
     end
   end
@@ -158,15 +157,9 @@ class Item < ActiveRecord::Base
     self.original_price   = item_that_this_is_being_exchanged_for.original_price
     self.price            = item_that_this_is_being_exchanged_for.price
     self.realized_price   = item_that_this_is_being_exchanged_for.realized_price
-    self.net              = item_that_this_is_being_exchanged_for.net
-    
-    if self.ticket?
-      self.discount = item_that_this_is_being_exchanged_for.discount
-      product.remove_from_cart
-      product.exchange_prices_from(item_that_this_is_being_exchanged_for.product)
-    end
-    
-    self.state = item_that_this_is_being_exchanged_for.state
+    self.net              = item_that_this_is_being_exchanged_for.net    
+    self.service_fee      = item_that_this_is_being_exchanged_for.service_fee
+    self.state            = item_that_this_is_being_exchanged_for.state
   end
 
   def to_comp!
@@ -188,6 +181,7 @@ class Item < ActiveRecord::Base
     self.price = 0
     self.realized_price = 0
     self.net = 0 
+    self.service_fee = 0
     self.discount = nil
     save   
   end
@@ -195,13 +189,17 @@ class Item < ActiveRecord::Base
   def modified?
     not %w( purchased comped ).include?(state)
   end
+
+  def dead?
+    refunded? || refund? || exchanged? || return?
+  end
   
   def return?
     state.eql? "returned"
   end
 
   #
-  # state="settled" means that obligations to thie producer are all done
+  # state="settled" means that obligations to the producer are all done
   #
   def settled?
     state.eql? "settled"
@@ -223,11 +221,10 @@ class Item < ActiveRecord::Base
     state.eql? "refunded"
   end
   
-  
   def exchanged?
     state.eql? "exchanged"
   end
-  
+
   #TODO: This isn't used anymore.  It needs to go
   def exchangee?
     state.eql? "exchangee"
@@ -251,6 +248,15 @@ class Item < ActiveRecord::Base
     self.update_all({:settlement_id => settlement.id, :state => :settled }, { :id => items.collect(&:id)})
   end
 
+  def assign_person(person)
+    product.buyer = person if ticket?
+    product.save!
+  end
+
+  def total_discount
+    original_price - price
+  end
+
   private
 
     def set_product_details_from(prod)
@@ -259,14 +265,19 @@ class Item < ActiveRecord::Base
     end
 
     def set_discount_from(prod)
-      self.discount = prod.discount
+      self.discount = prod.discount if prod.respond_to?(:discount)
+    end
+
+    def set_pass_from(prod)
+      self.pass = prod.pass if prod.respond_to?(:pass)
     end
 
     def set_prices_from(prod)
       self.original_price = prod.price
-      self.price          = (prod.sold_price || prod.price)
-      self.realized_price = self.price - prod.class.fee
+      self.price          = (prod.sold_price || prod.cart_price || prod.price)
+      self.realized_price = self.price - prod.realized_fee
       self.net            = (self.realized_price - (per_item_processing_charge || lambda { |item| 0 }).call(self)).floor
+      self.service_fee    = prod.service_fee || 0
     end
 
     def set_show_from(prod)

data/app/models/job/checkout_processor.rb

@@ -0,0 +1,46 @@
+#
+# This class excapsulate asynchrnous things we can do during or immediately following checkout
+# usually involving the payment or customer objects (which aren't available after checkout)
+# Examples: Updating a patron phone or address
+#
+# This class is not for order-related processing things. See OrderProcessor for that
+#
+# This class WILL NOT RUN ASYNC in test envs
+#
+class CheckoutProcessor < Struct.new(:person, :first_name, :last_name, :address_hash, :phone, :time_zone, :checkout_name)
+  QUEUE = "checkout"
+
+  def initialize(person, customer, address, phone, time_zone, checkout_name = "checkout")
+    self.person         = person
+    self.first_name     = customer.first_name
+    self.last_name      = customer.last_name
+    self.address_hash   = address.attributes.to_options unless address.nil?
+    self.phone          = phone
+    self.time_zone      = time_zone
+    self.checkout_name  = checkout_name
+  end
+
+  def self.process(person, customer, address, phone, time_zone, checkout_name)
+    job = CheckoutProcessor.new(person, customer, address, phone, time_zone, checkout_name)
+    
+    if job.run_now?
+      job.perform
+    else
+      Delayed::Job.enqueue job, :queue => QUEUE
+    end
+  end
+
+  def perform
+    self.person.update_name(self.first_name, self.last_name)
+    self.person.update_address(self.address_hash, self.time_zone, nil, checkout_name) if address_exists?
+    self.person.add_phone_if_missing(self.phone)
+  end
+
+  def run_now?
+    Rails.env.test?
+  end
+
+  def address_exists?
+    self.address_hash.present? && self.address_hash.values.select{|values| values.present?}.any?
+  end
+end