artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/imports/memberships_import.rb

@@ -8,36 +8,234 @@ class MembershipsImport < Import
   
   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, "No Email included in this row: #{parsed_row.row}" unless attach_person(parsed_row).email.present?
     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?
+    valid_amount?          parsed_row.unparsed_amount unless parsed_row.unparsed_amount.blank?
+    valid_date?            parsed_row.order_date unless parsed_row.order_date.blank?
+
+    case detect_membership_type(parsed_row.membership_type).to_s
+    when RollingMembershipType.to_s
+      valid_date? parsed_row.start_date
+      raise Import::RowError, "Please include a 'Period' for Rolling membership: #{parsed_row.row}" if parsed_row.period.blank?
+      raise Import::RowError, "Please include a 'Duration' for Rolling membership: #{parsed_row.row}" if parsed_row.duration.blank?
+    when SeasonalMembershipType.to_s
+      valid_date? parsed_row.start_date
+      valid_date? parsed_row.end_date
+    end
+
     true
   end
-  
+
+  def new_membership_types
+    self.import_rows.select('membership_name, membership_type, count(id) as member_count').where(membership_type_exists: false).group('membership_name')
+  end
+
+  def existing_membership_types
+    self.import_rows.select('membership_name, membership_type, count(id) as member_count').where(membership_type_exists: true).group('membership_name')
+  end
+
+  def index_parsed_row(parsed_row)
+    import_row = super
+    import_row.membership_type = parsed_row.membership_type
+    import_row.membership_name = parsed_row.membership_name
+    import_row.membership_type_exists = find_membership_type(parsed_row).present?
+    import_row
+  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)
+    person          = create_person(parsed_row)
+    member          = create_member(person)
+    membership_type = create_membership_type(parsed_row)
+    order           = create_order(parsed_row, person, member, membership_type)
+  end
+
+  def create_person(parsed_row)
+    new_person = attach_person(parsed_row)
+
+    existing_person = Person.first_or_initialize( {:email => new_person.email, :organization => self.organization} ) do |p|
+      p.type    = new_person.type
+      p.subtype = new_person.subtype
+    end
+
+    if existing_person.new_record?
+      existing_person.import = self
+    else
+      message(nil, parsed_row, existing_person, "#{existing_person.email} exists. Will merge records.")
+    end
+
+    existing_person.update_from_import(new_person)
+    existing_person.skip_commit = true
+
+    unless existing_person.save
+      message = []
+      message << "#{parsed_row.email}: " unless parsed_row.email.blank?
+      message << person.errors.full_messages.join(', ')
+      raise Import::RowError, message.join('')
+    end
+
+    existing_person
+  end
+
+  def create_member(person)
+    member = self.members.where(:person_id => person.id, :organization_id => self.organization_id).first
+
+    unless member
+      member              = self.members.build
+      member.email        = person.email
+      member.password     = Devise.friendly_token.first(15)
+      member.person       = person
+      member.organization = self.organization
+      member.save!
+    end
+
+    member
   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 = find_membership_type(parsed_row)
+
+    unless membership_type
+      klass                        = detect_membership_type(parsed_row.membership_type)
+      membership_type              = klass.new
+      membership_type.import_id    = self.id
+      membership_type.name         = parsed_row.membership_name
+      membership_type.description  = parsed_row.membership_name
+      membership_type.organization = self.organization
+      membership_type.price        = parsed_row.amount
+
+      case klass.to_s
+      when SeasonalMembershipType.to_s
+        membership_type.starts_at = DateTime.parse(parsed_row.start_date)
+        membership_type.ends_at   = DateTime.parse(parsed_row.end_date)
+      when RollingMembershipType.to_s
+        membership_type.starts_at = DateTime.parse(parsed_row.start_date)
+        membership_type.duration  = parsed_row.duration
+        membership_type.period    = parsed_row.period
+      else
+        raise Import::RowError, "Unknown membership type #{klass}"
+      end
+
+      membership_type.save(:validate => false)
+    end
+
     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)
+  def find_membership_type(parsed_row)
+    membership_type = MembershipType.where(
+      :name            => parsed_row.membership_name,
+      :organization_id => self.organization.id
+    ).first
+  end
+
+  def create_membership(parsed_row, member, membership_type)
+    membership                 = self.memberships.build
+    membership.organization    = self.organization
+    membership.membership_type = membership_type
+    membership.member          = member
+    membership.price           = parsed_row.amount
+    membership.sold_price      = parsed_row.amount
+    membership.cart_price      = parsed_row.amount
+    membership.total_paid      = parsed_row.amount
+
+    membership.starts_at       = DateTime.parse(parsed_row.start_date)
+
+    case membership_type.type
+    when SeasonalMembershipType.to_s
+      membership.ends_at = DateTime.parse(parsed_row.end_date)
+    when RollingMembershipType.to_s
+      membership.ends_at = membership.starts_at + membership_type.duration_in_seconds
+    else
+      raise Import::RowError, "Failed to create a membership of type: #{membership_type}"
+    end
+
+    membership.save!
+    membership
+  end
+
+  def existing_order(person, membership_type, payment_method)
+    # lookup order ids:
+    #   for membership(s):
+    #     + of the same membership type
+    #     + with the same payment method
+    #     + and the same buyer
+    existing_orders = ImportedOrder.joins(:items).where orders: {
+                                                           import_id: self.id,
+                                                           person_id: person.id,
+                                                           payment_method: payment_method
+                                                         },
+
+                                                        items: {
+                                                          product_type: 'Membership',
+                                                          product_id: membership_type.id
+                                                        }
+    order = existing_orders.last
+    ImportedOrder.find(order.id) if order
+  end
+
+  def create_order(parsed_row, person, member, membership_type)
+    order = existing_order(person, membership_type, parsed_row.payment_method) || ImportedOrder.new
+
+    order.organization = self.organization
+    order.payment_method = parsed_row.payment_method
+    order.person = person
+    order.details = "Imported by #{user.email} on #{I18n.l self.created_at_local_to_organization, :format => :date}"
+    order.import = self
+
+    product = create_membership(parsed_row, member, membership_type)
+
+    item = Item.for(product, order)
+    item.state = "settled"
+    order.items << item
+
+    order.skip_actions = true
+    order.save
+    unless parsed_row.order_date.blank?
+      date_in_zone = DateTime.parse(parsed_row.order_date)
+      order_date = date_in_zone - time_zone_parser.utc_offset.seconds
+
+      order.update_attribute(:created_at, order_date)
+    end
+
+    order.create_generic_action(:memberships, self.id)
+    order.actions.where(:type => 'GetAction').first.update_attribute(:occurred_at, order.created_at)
+
+    order
+  end
+
+  def detect_membership_type(type)
+    case type.to_s.downcase
+    when /seasonal/
+      SeasonalMembershipType
+    when /rolling/
+      RollingMembershipType
+    else
+      raise Import::RowError, "Unknown Membership Type: #{type}"
+    end
+  end
+
+  def rollback
+    rollback_orders
+    rollback_actions
+    rollback_memberships
+    rollback_membership_types
+    rollback_people
+  end
+
+  def rollback_members
+    Member.where(:import_id => self.id).destroy_all
+  end
+
+  def rollback_memberships
+    Membership.where(:import_id => self.id).destroy_all
+  end
+
+  def rollback_membership_types
+    MembershipType.where(:import_id => self.id).destroy_all
+  end
+
+  def rollback_actions
+    Action.where(:import_id => self.id).destroy_all
   end
 end

data/app/models/imports/people_import.rb

@@ -38,6 +38,14 @@ class PeopleImport < Import
     #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?
     
+    if parsed_row.birth_month.present?
+      raise Import::RowError, "Incorrect month: '#{parsed_row.birth_month}' in this row: #{parsed_row.row}" unless parsed_row.birth_month.to_i.between?(1,12)
+    end
+    
+    if parsed_row.birth_day.present?
+      raise Import::RowError, "Incorrect day: '#{parsed_row.birth_day}' in this row: #{parsed_row.row}" unless parsed_row.birth_day.to_i.between?(1,31)
+    end
+    
     #We're bypassing the valid? check that used to be here because we're allowing dupe emails (they get merged later)
     true
   end
@@ -66,4 +74,4 @@ class PeopleImport < Import
     end
     existing_person  
   end
-end
+end

data/app/models/imports/rollback.rb

@@ -12,5 +12,14 @@ module Imports
         Rails.logger.debug result
       end
     end
+
+    def rollback_campaigns
+      Campaign.where(:import_id => self.id).where(:organization_id => self.organization.id).all.each {|o| o.destroy(:with_prejudice => true)}
+    end
+
+    def rollback_appeals
+      Appeal.where(:import_id => self.id).where(:organization_id => self.organization.id).all.each {|o| o.destroy(:with_prejudice => true)}
+    end
+
   end
 end

data/app/models/imports/validations.rb

@@ -16,6 +16,13 @@ module Imports
       rescue
         raise Import::RowError, "Invalid date: #{date_str}  Make sure the date is in the format YEAR/MONTH/DAY (2012/04/18) or DAY-MONTH-YEAR (18-Apr-12)."
       end    
+
+      parsed_date = DateTime.parse(date_str)
+
+      if(parsed_date.year < 1900)
+        raise Import::RowError, "Invalid date: #{date_str}  Make sure the date is in the format YEAR/MONTH/DAY (2012/04/18) or DAY-MONTH-YEAR (18-Apr-12)."
+      end
+
       true
     end  
     

data/app/models/individual.rb

@@ -1,6 +1,8 @@
 class Individual < Person
 
-  after_destroy { |record| Delayed::Job.enqueue(CleanupSuggestedHouseholdsJob.new(record.id), :queue => :suggested_households) }
+  after_destroy do |record|
+    Delayed::Job.enqueue(CleanupSuggestedHouseholdsJob.new(record.id), :queue => :suggested_households)
+  end
 
   def to_s
     if first_name.present? || last_name.present?

data/app/models/item.rb

@@ -15,13 +15,19 @@ class Item < ActiveRecord::Base
   belongs_to :pass
 
   attr_accessible :order_id, :product_type, :state, :price, :realized_price, :net, :nongift_amount
-  
+
   #This is a lambda used to by the items to calculate their net
   attr_accessor :per_item_processing_charge
 
+  #A float value used to calculate how much of a product's realized fee applies to this item
+  attr_accessor :realized_fee_modifier
+
   validates_presence_of :product_type, :price, :realized_price, :net
   validates_inclusion_of :product_type, :in => %( Ticket Donation Membership Pass)
 
+  after_save { order.solr_index! if order }
+  after_destroy { order.solr_index! if order }
+
   scope :donation,        where(:product_type => 'Donation')
   scope :membership,      where(:product_type => 'Membership')
   scope :ticket,          where(:product_type => 'Ticket')
@@ -48,13 +54,39 @@ class Item < ActiveRecord::Base
     product_type == "Pass"
   end
 
-  def self.donations_by(person)
-    Item.donation.joins(:order).where('orders.person_id' => person.id)
+  def self.donations_count_by(person)
+    self.select('(COUNT(DISTINCT orders.parent_id) + SUM(orders.parent_id IS NULL)) AS donations_count')
+        .joins(:order)
+        .joins('LEFT JOIN donations ON donations.id = items.product_id')
+        .where(:product_type => 'Donation')
+        .where('donations.pledge' => false)
+        .where("items.state != 'refund' AND items.state != 'refunded'")
+        .where('orders.person_id' => person.id).first.donations_count.to_i
+
+  end
+
+  #
+  # realized_fee is the fee charged to the producer by withholding it
+  # from any settlements.
+  #
+  # Note that thisis different from the (now poorly named) service_fee which is
+  # money we've charged to the patron at checkout time
+  #
+  def realized_fee
+    price - realized_price
+  end
+
+  def total_fee
+    realized_fee + service_fee
+  end
+
+  def producer_liability
+    self.price - realized_fee
   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 
+  # then re-sold to someone else, this item will still show up on the original purchaser's
   # action feed
   #
   def order_summary_description
@@ -88,10 +120,11 @@ class Item < ActiveRecord::Base
     1
   end
 
-  def self.for(prod, per_item_lambda=lambda { |item| 0 })
+  def self.for(prod, order)
     Item.new.tap do |i|
-      i.per_item_processing_charge = per_item_lambda
-      i.product = prod 
+      i.per_item_processing_charge = order.try(:per_item_processing_charge) || lambda { |item| 0 }
+      i.realized_fee_modifier      = order.try(:realized_fee_modifier) || 1
+      i.product = prod
     end
   end
 
@@ -128,6 +161,11 @@ class Item < ActiveRecord::Base
     (not dead?) and product and product.returnable?
   end
 
+  def convertable?
+    (not dead?) and product and product.convertable?
+  end
+
+
   #
   # This looks bad, but here's what's going on
   # the item that gets refunded is state="refunded"
@@ -158,7 +196,7 @@ 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    
+    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
@@ -181,10 +219,10 @@ class Item < ActiveRecord::Base
     self.original_price = 0
     self.price = 0
     self.realized_price = 0
-    self.net = 0 
+    self.net = 0
     self.service_fee = 0
     self.discount = nil
-    save   
+    save
   end
 
   def modified?
@@ -194,7 +232,7 @@ class Item < ActiveRecord::Base
   def dead?
     refunded? || refund? || exchanged? || return?
   end
-  
+
   def return?
     state.eql? "returned"
   end
@@ -205,23 +243,23 @@ class Item < ActiveRecord::Base
   def settled?
     state.eql? "settled"
   end
-  
+
   def purchased?
     state.eql? "purchased"
   end
-  
+
   def comped?
     state.eql? "comped"
   end
-  
+
   def refund?
     state.eql? "refund"
   end
-  
+
   def refunded?
     state.eql? "refunded"
   end
-  
+
   def exchanged?
     state.eql? "exchanged"
   end
@@ -276,7 +314,7 @@ class Item < ActiveRecord::Base
     def set_prices_from(prod)
       self.original_price = prod.price
       self.price          = (prod.sold_price || prod.cart_price || prod.price)
-      self.realized_price = self.price - prod.realized_fee
+      self.realized_price = self.price - ((self.realized_fee_modifier || 1) * 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