artfully_ose 1.2.0.beta.1 → 1.2.0.pre

data/app/models/member.rb

@@ -2,8 +2,6 @@ class Member < ActiveRecord::Base
 
   include Ext::DeviseConfiguration
   include Ext::Integrations::Member
-  include Ext::Uuid
-  include Ext::S3Link
 
   has_many    :memberships
   belongs_to  :organization
@@ -12,108 +10,16 @@ class Member < ActiveRecord::Base
   validates :organization,  :presence => true
   validates :member_number,  :presence => true
 
-  before_validation :set_member_number, :unless => :persisted?
-
-  CURRENT = :current
-  LAPSED  = :lapsed
-  PAST    = :past
-  NONE    = :none
-
-  scope :current, where("current_memberships_count > 0")
-  scope :lapsed,  where("lapsed_memberships_count > 0").where("current_memberships_count = 0")
-  scope :past,    where("past_memberships_count > 0").where("lapsed_memberships_count = 0").where("current_memberships_count = 0")
-
-  has_attached_file :pdf, MEMBER_PDF_STORAGE
-  has_attached_file :qr_code, MEMBER_QR_STORAGE
-  delegate :url, :to => :qr_code, :prefix => true
-
-  #
-  # devise_invitable needs this otherwise it can't set the :from param in an email
-  #
-  def headers_for(action)
-    case action.to_s
-    when "invitation_instructions"
-      {:from => self.organization.email}
-    else
-      {}
-    end
-  end
-
-  #
-  # returns an array of attachments in this format: [ [filename, file], [filename, file] ]
-  #
-  def attachments_for(action)
-    case action.to_s
-    when "invitation_instructions"
-      [ ["membership_card.pdf", member_card_pdf] ]
-    else
-      []
-    end
-  end
-
-  def member_card_pdf
-    file = Tempfile.new(["member#{self.id}", '.pdf'])
-    self.pdf.copy_to_local_file(:original, file)
-    file.rewind
-    file.read
-  end
-
-  def current_membership_types
-    memberships.current.collect(&:membership_type)
-  end
-
-  def member_tickets_purchased_for(event)
-    Ticket.joins(:ticket_type)
-          .joins(:show => :event)
-          .where(:buyer_id => self.person.id)
-          .where('shows.event_id' => event.id)
-          .where('ticket_types.member_ticket = 1')
-  end
-
-  #
-  # This is always run DJ'd
-  #
-  def count_memberships
-    self.current_memberships_count  = self.memberships.current.count
-    self.lapsed_memberships_count   = self.memberships.lapsed.count
-    self.past_memberships_count     = self.memberships.past.count
-    self.save
-  end
-  handle_asynchronously :count_memberships
-
-  #
-  # Intentionally did not use a state machine for this for a few reasons
-  # 1) I'm not all that happy with transitions
-  # 2) Can't find another state machine that I like and is worth the cost of switching to
-  # 3) This works just fine. I prefer calculating state on the fly here because we're couning the memberships
-  #    on this member anyway
-  # 4) Determining a lapsed or past member is a touch more complicated than it sounds
-  #    A lapsed member is a member with lapsed memberships *and no current memberships*
-  #    It's that last bit that makes grabbing all last members quite difficult in SQL
-  #
-  # Note that this method uses the cached values for current_memberships, lapsed_memberships, and past_memberships
-  #
-  def state
-    return CURRENT if self.current_memberships_count > 0
-    return LAPSED  if self.lapsed_memberships_count  > 0
-    return PAST    if self.past_memberships_count    > 0
-    return NONE
-  end
-
-  def self.states
-    [CURRENT, LAPSED, PAST, NONE]
-  end
-
-  self.states.each do |st|
-    define_method "#{st}?" do
-      "#{st}".to_s == self.state.to_s
-    end
-  end
+  before_create :set_member_number
 
   def self.generate_password
     Devise.friendly_token
   end
 
+  def active_memberships
+    memberships.select{ |m| m.starts_at < DateTime.now && m.ends_at > DateTime.now }
+  end
+
   def set_member_number
     self.member_number = MemberNumberGenerator.next_number_for(self.organization)
   end
@@ -125,67 +31,26 @@ class Member < ActiveRecord::Base
     super && !suspended?
   end
 
-  def self.find_by_membership(membership, person)
-    Member.find_by_email_and_organization_id(person.email, membership.organization)    #TODO: Biggest join ever
-  end
-
-  def member_through
-    self.memberships.map{|membership| membership.ends_at}.max
+  def self.find_by_membership(membership)
+    Member.find_by_email_and_organization_id(membership.item.order.person.email, membership.organization)    #TODO: Biggest join ever
   end
 
   #
-  # * Creates a member for this membership if one does not already exist
+  # * Creates (and invites) a member for this membership if one does not already exist
   # * Attaches that member to the applicable person
-  # * Invites that member if membership.send_email is true
-  # * Generates a new qr code if this is a new member
-  # * Generates a membership card if this is a new member
-  #
-  # This method CANNOT be run in any synchronous flow
   #
-  def self.for(membership, person)
-    member = Member.find_by_membership(membership, person)
-
+  def self.for(membership)
+    member = Member.find_by_membership(membership)
     if member.nil?
-      member = Member.create!({:email => person.email,
-                               :organization => membership.organization,
-                               :person => person,
-                               :password => SecureRandom.hex(32)}, :without_protection => true)
-
-      member.person.create_address if member.person.address.nil?
-
-      membership.member = member
-      membership.save
-
-      member.generate_qr_code
-      member.generate_pdf
-
-      member.invite! if membership.send_email
-    else
-      membership.member = member
-      membership.save
+      member = Member.new({:email => membership.item.order.person.email})
+      member.organization = membership.item.order.organization
+      member.person = membership.item.order.person
+      member.invite!
     end
 
-    member
-  end
-
-  def generate_pdf
-    pdf = PdfGeneration.new(self).generate
-    file = Tempfile.new(["#{self.id}", '.pdf'])
-    file << pdf.force_encoding("UTF-8")
-    self.pdf = file
-    self.save
-  end
-
-  def generate_qr_code
-    file = Tempfile.new(['qr-code', '.png'])
-    Ticket::QRCode.new(self, nil).render(file)
-    self.qr_code = file
-
-    # If we don't save the ticket here, paperclip will leak a file handle.
-    # Even though we close our Tempfile below, paperclip copies that into
-    # another Tempfile, and only closes the handle when the ticket is saved.
-    save
+    membership.member = member
+    membership.save
 
-    file.close
+    member
   end
 end

data/app/models/membership.rb

@@ -1,89 +1,52 @@
-#
-# service_fee represents the fee displayed to the patron in the cart.
-# If the producer is eating the fee, service_fee is 0
-#
 class Membership < ActiveRecord::Base
-  include Extendable
-
+  include Itemable
   belongs_to :organization
   belongs_to :member
   belongs_to :membership_type
   has_many :items, :as => :product
 
-  # Same callbacks that fire before Rails' built-in counter_cache
-  #Except before_destroy is replaced with after_destroy
-  after_create    :update_member_counters
-  after_destroy   :update_member_counters
-  after_update    :update_member_counters
-
-  #
-  # Make sure you're scoping when you use these. 
-  # organization.memberships.lapsed
-  #
-  scope :expired, lambda { |time = Time.now| where("ends_at < ?", time) }
-  scope :current, lambda { |time = Time.now| where("ends_at > ?", time) }
-  scope :lapsed,  lambda { |time = Time.now, since = (time - 1.year)| where("ends_at < ?", time).where("ends_at > ?", since.midnight) }
-  scope :past,    lambda { |time = Time.now| where("ends_at < ?", time - 1.year) }
-
-  belongs_to :changed_membership, :class_name => "Membership"
-  has_one    :changed_to, :class_name => "Membership", :foreign_key => "changed_membership_id"
-
-  def self.for(membership_type, member = nil)
+  def self.for(membership_type)
     new.tap do |membership|
       membership.membership_type  = membership_type
       membership.organization     = membership_type.organization
-      membership.price            = membership_type.price_for(member)
-      membership.cart_price       = membership.price
-      membership.sold_price       = membership.price
-      membership.total_paid       = membership.price
+      membership.price            = membership_type.price
       membership.starts_at        = membership_type.starts_at
       membership.ends_at          = membership_type.ends_at
     end
   end
 
-  def changed?
-    self.changed_to.present?
-  end
+  # TODO: DJ this. Could be thousands of people.
+  def self.for_award(membership_award)
+    membership_award.people.each do |people|
+      Rails.logger.debug("                              MEMBERSHIP FOR #{people}")
+      membership              = Membership.for(membership_award.membership_type)
+      membership.ends_at      = membership_Award.ends_at
+      membership.sold_price   = membership_award.sold_price
 
-  def changee?
-    self.changed_membership.present?
+      # create order
+      # Member.for(membership)
+    end
   end
 
-  def update_member_counters
-    self.member.try(:count_memberships)
+  def adjust_expiration_to(new_ends_at)
+    self.ends_at = new_ends_at
+    self.save
   end
 
   def item
     items.first
   end
 
-  def self.realized_fee
-    0
+  def cart_price
+    price 
   end
 
-  def realized_fee 
-    self.membership_type.hide_fee? ? self.cart_price * MembershipType::SERVICE_FEE : 0
-  end
-
-  def self.to_sentence(memberships)
-    if memberships.any?
-      membership_types = memberships.collect(&:membership_type).uniq
-      if membership_types.length > 1
-        "multiple memberships"
-      else
-        ActionController::Base.helpers.pluralize(memberships.length, "#{memberships.first.membership_type.membershipize}")
-      end
-    else
-      "No memberships"
-    end
-  end
-
-  def expired?
-    ends_at < Time.now
+  def self.realized_fee
+    0
   end
 
   def refundable?
-    true
+    false
   end
 
   def exchangeable?
@@ -97,4 +60,5 @@ class Membership < ActiveRecord::Base
   def order_summary_description
     self.membership_type.name
   end
-end
+
+end

data/app/models/membership_award.rb

@@ -0,0 +1,23 @@
+class MembershipAward
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+  include ActiveModel::Validations
+
+  attr_accessor :people,
+                :search, 
+                :organization, 
+                :membership_type, 
+                :number_of_memberships, 
+                :ends_at, 
+                :message, 
+                :send_email,
+                :sold_price
+
+  def persisted?
+    false
+  end
+
+  def people_ids
+    people.nil? ? [] : people.collect(&:id)
+  end
+end

data/app/models/membership_type.rb

@@ -1,11 +1,5 @@
 class MembershipType < ActiveRecord::Base
-  include Ext::Integrations::ServiceFee
-  extend ::ArtfullyOseHelper
-  attr_accessible :name, :price, :fee, :number_of_shows, 
-                  :plan, :on_sale, :description, :ends_at, 
-                  :starts_at, :duration, :type, :period, :number_of_tickets, :sales_start_at, :sales_end_at,
-                  :thanks_copy, :invitation_email_text_copy, :hide_fee, :renewal_price, :offer_renewal,
-                  :limit_per_transaction
+  attr_accessible :name, :price, :fee, :number_of_shows, :plan, :on_sale, :description, :ends_at, :starts_at
 
   belongs_to :organization
   has_many :memberships
@@ -14,53 +8,17 @@ class MembershipType < ActiveRecord::Base
 
   after_create :create_list_segment
   
-  validates :name, :description, :price, :presence => true
-
-  scope :storefront, where(:on_sale => true)
+  default_scope order("created_at DESC")
   scope :on_sale, where(:on_sale => true)
-  scope :sales_valid, where("sales_start_at < ? or sales_start_at is null", DateTime.now).where("sales_end_at > ? or sales_end_at is null", DateTime.now)
-  scope :not_ended, where('ends_at > ?', DateTime.now)
-
-  comma do
-    name
-    description
-    price                      { |price| MembershipType.number_as_cents price }
-    type
-    memberships 'Memberships sold' do |m|
-      m.count
-    end
-    members { |m| m.distinct(:member_id).count }
-    duration
-    period
-    starts_at
-    ends_at
-    on_sale
-    sales_start_at
-    sales_end_at
-  end
-
-  def self.in_play(organization)
-    self.find((organization.membership_types.not_ended.pluck(:id).uniq + organization.memberships.current.select(:membership_type_id).uniq.pluck(:membership_type_id)))
-  end
 
   def membershipize
     self.name.end_with?("Membership") ? self.name : self.name + " Membership"
   end
 
-  def price_for(member = nil)
-    return price if member.nil?
-
-    (offer_renewal? && member.current?) ? renewal_price : price
-  end
-
   def create_list_segment
     @search = organization.searches.create({:membership_type => self})
     @segment = organization.segments.create({:search => @search, :name => self.name})
     self.segment = @segment
     save
   end
-
-  def allow_multiple_memberships?
-    self.limit_per_transaction > 1
-  end
 end

data/app/models/note.rb

@@ -1,7 +1,7 @@
 class Note < ActiveRecord::Base
   attr_accessible :occurred_at, :text
   
-  belongs_to :person, touch: true
+  belongs_to :person
   belongs_to :user
   belongs_to :organization
 end

data/app/models/order_handler.rb

@@ -2,19 +2,10 @@
 # Handles orders in progress for which customers have not paid
 #
 class OrderHandler
-  attr_accessor :discount_error, :over_limit, :cart, :error, :member
+  attr_accessor :discount_error, :over_limit, :cart, :error
 
-  def initialize(cart, member)
+  def initialize(cart)
     self.cart = cart
-    self.member = member
-  end
-
-  def handle(params, store_organization)
-    self.handle_tickets(params)    
-    self.handle_donation(params, store_organization)
-    self.handle_memberships(params, self.member)
-    self.handle_passes(params)
-    self.handle_discount_or_pass_code(params)
   end
 
   def handle_tickets(params)
@@ -24,7 +15,7 @@ class OrderHandler
 
       ticket_type = TicketType.find(params[:ticket_type_id])
       Rails.logger.debug("QUANTITY #{params[:quantity].to_i}")
-      tickets = ticket_type.available_tickets(params[:quantity].to_i, member)
+      tickets = ticket_type.available_tickets(params[:quantity].to_i)
       ids = tickets.collect(&:id)
       Rails.logger.debug("TICKET IDS: #{ids}")
       Ticket.lock(tickets, ticket_type, self.cart)
@@ -40,115 +31,63 @@ class OrderHandler
     params
   end
 
-  def handle_donation(params, organization)
-    donation_amount = params[:donation_amount].present? ? params[:donation_amount] : params[:donation_amount_fixed]
-    if donation_amount
-      self.cart.clear_donations
-      if donation_amount.to_i == 0
-        self.error = "Please enter a donation amount."
-        return
-      end
-      
-      donation = Donation.new
-      donation.amount = donation_amount.to_i * 100
-      donation.organization = organization
-      self.cart.donations << donation
-    end
-  end
-
-
-  def handle_memberships(params, member = nil)
-    unless params[:membership_type].blank?
-      membership_type_id = params[:membership_type][:id]
-      quantity = params[:quantity].to_i
-      
-      if membership_type_id.blank?
-        self.error = "Please select a membership."
-        return
-      end
-      
-      (1..quantity).each do |i|
-        if allowed_to_add?(membership_type_id)
-          self.cart.memberships << Membership.for(MembershipType.find(membership_type_id), member)
-        else
-          self.error = "Sorry, we can't add any more of this membership type to your cart."
-        end
-      end
-    end
-  end
-
-  #
-  # Note that this handles passes *currently being purchased* NOT passes that are being applied to the cart
-  #
-  def handle_passes(params)
-    Rails.logger.debug(params)
-    unless params[:pass_type].blank?
-      pass_type_id = params[:pass_type][:id]
-      quantity = params[:quantity].to_i
-
-      if pass_type_id.blank?
-        self.error = "Please select a pass."
-        return
-      end
-
-      (1..quantity).each do |i|
-        self.cart.passes << Pass.for(PassType.find(pass_type_id))
-      end
-      
-    end    
-  end
-
-  def is_pass?(code)
-    Pass.where(:pass_code => code).any?
-  end
-
-  def handle_discount_or_pass_code(params)
-    if params[:discount_or_pass_code].present?
-      is_pass?(params[:discount_or_pass_code]) ? apply_pass(params) : handle_discount(params)
-    end
-  end
-
-  private 
-
-    def handle_discount(params)
+  def handle_discount(params)
+    if params[:discount].present?
       begin
-        discount = nil
+        @discount = nil
         self.cart.tickets.each do |ticket|
-          discount = Discount.find_by_code_and_event_id(params[:discount_or_pass_code].upcase, ticket.show.event.id)
-          unless discount.nil?
-            discount.apply_discount_to_cart(self.cart)
+          @discount = Discount.find_by_code_and_event_id(params[:discount].upcase, ticket.show.event.id)
+          Rails.logger.debug(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> #{@discount}")
+          unless @discount.nil?
+            @discount.apply_discount_to_cart(self.cart)
             break
           end
         end
 
-        if discount.nil?
+        if @discount.nil?
           self.error = "We could not find your discount. Please try again."
         end
       rescue RuntimeError => e
         self.error = e.message
-        params[:discount_or_pass_code] = nil        
+        params[:discount] = nil        
       rescue NoMethodError => e
         Rails.logger.error(e)
         Rails.logger.error(e.backtrace)
         self.error = "We could not find your discount. Please try again."
-        params[:discount_or_pass_code] = nil
+        params[:discount] = nil
       end
-      discount
     end
+    @discount
+  end
 
-    def apply_pass(params)
-      @pass = Pass.where(:pass_code => params[:discount_or_pass_code]).first
-      @pass.apply_pass_to_cart(self.cart)
-      self.error = @pass.errors.full_messages.to_sentence unless @pass.errors.empty?
-      @pass
+  def handle_donation(params, organization)
+    if params[:donation_amount]
+      self.cart.clear_donations
+      if params[:donation_amount].to_i == 0
+        flash[:error] = "Please enter a donation amount."
+        return
+      end
+      
+      donation = Donation.new
+      donation.amount = params[:donation_amount].to_i * 100
+      donation.organization = organization
+      self.cart.donations << donation
     end
+  end
 
-    def allowed_to_add?(membership_type_id)
-      @type = MembershipType.find(membership_type_id)
 
+  def handle_memberships(params)
+    unless params[:membership_type].blank?
+      membership_type_id = params[:membership_type][:id]
+      quantity = params[:quantity].to_i
+      
       #how many memberships of this type are in the cart?
-      current_membership_type_count = self.cart.memberships.select{ |membership| membership.membership_type_id == membership_type_id.to_i }.length
+      #current_membership_type_count = self.cart.memberships.count{ |membership| membership.membership_type_id == membership_type_id }
 
-      return current_membership_type_count < @type.limit_per_transaction
+      (1..quantity).each do |i|
+        self.cart.memberships << Membership.for(MembershipType.find(membership_type_id))
+      end
+      
     end
+  end
 end