artfully_ose 1.2.0.beta.1 → 1.2.0.pre

data/app/models/membership_cancellation.rb

@@ -1,80 +0,0 @@
-class MembershipCancellation
-  attr_reader :cancelled_memberships
-  attr_reader :membership_ids
-
-  def initialize(membership_ids=nil)
-    @cancelled_memberships = []
-    @membership_ids        = Array.wrap(membership_ids) unless membership_ids.nil?
-  end
-
-  def self.enqueue(membership_ids)
-    membership_ids = Array.wrap(membership_ids)
-    Delayed::Job.enqueue(MembershipCancellation.new(membership_ids))
-  end
-
-  def expired_at
-    @expired_at ||= 1.second.ago
-  end
-
-  def memberships
-    @memberships ||= Membership.where(id: membership_ids)
-  end
-
-  def non_refundables
-    @non_refundables ||= memberships.select { |m| !m.item.refundable? || !m.item.order.credit?}
-  end
-
-  def refund_available?
-    !refundables.blank?
-  end
-
-  def refund_amount
-    @refund_amount ||= refundables.map(&:price).sum
-  end
-
-  def refundables
-    @refundables ||= memberships.select {|m| m.item.refundable? && m.item.order.credit? }
-  end
-
-  def refundables_for(order)
-    refundables.select { |r| r.item.order.id == order.id }
-  end
-
-  def refundable_orders
-    @refundable_orders ||= refundables.map(&:item).map(&:order).uniq
-  end
-
-  def perform
-    Order.transaction do
-
-      # Handle refunds
-      refundable_orders.each do |order|
-        # Find refundable memberships for this order
-        refundables = refundables_for(order)
-
-        # Submit the refund
-        refund = Refund.new(order, refundables.map(&:item))
-        refund.submit(:send_email_confirmation => true)
-
-
-        cancel_memberships!(refundables) if refund.successful?
-      end
-
-      # Cancel non-refundable memberships
-      cancel_memberships!(non_refundables)
-    end
-  end
-
-  def owner
-    @owner ||= memberships.first.item.order.person
-  end
-
-  private
-
-  def cancel_memberships!(memberships)
-    memberships.map do |m|
-      m.adjust_expiration_to expired_at
-      @cancelled_memberships << m
-    end
-  end
-end

data/app/models/membership_change.rb

@@ -1,187 +0,0 @@
-class MembershipChange
-  include ActiveModel::Validations
-
-  attr_reader :cart
-  attr_reader :checkout
-  attr_reader :changing_memberships
-  attr_reader :new_memberships
-  attr_reader :payment
-
-  attr_accessor :credit_card_info
-  attr_accessor :membership_ids
-  attr_accessor :membership_type_id
-  attr_accessor :payment_method
-  attr_accessor :person_id
-  attr_accessor :price
-
-  validates :person_id, :presence => true
-  validates :membership_ids, :presence => true
-  validates :membership_type_id, :presence => true
-  validates :payment_method, :presence => true
-  validates :price, :presence => true
-  validates :credit_card_info, :presence => {:if => :credit?}
-
-  # This is purely to assuage shoulda and it's validation matchers
-  def self.reflect_on_association(a)
-    return false
-  end
-
-  def initialize(params = nil)
-    @price = 0
-    assign_params(params) if params
-  end
-
-  def assign_params(new_params)
-    return if new_params.blank?
-
-    params = new_params.stringify_keys
-    params.each do |k,v|
-      if respond_to?("#{k}=")
-        send("#{k}=", v)
-      else
-        raise(ArgumentError, "unknown parameter: #{k}")
-      end
-    end
-  end
-
-  def cart
-    unless @cart
-      @cart = Cart.create
-
-      # Add the new memberships
-      new_memberships.each do |membership|
-        @cart.memberships << membership
-      end
-    end
-    @cart
-  end
-
-  def changing_memberships
-    @changing_memberships ||= Membership.where(id: membership_ids)
-  end
-
-  def checkout
-    @checkout ||= MembershipChange::Checkout.new(cart, payment)
-  end
-
-  def comp?
-    'comp' == payment_method
-  end
-
-  def credit?
-    !!(payment_method =~ /credit|cc/)
-  end
-
-  def membership_type
-    @membership_type ||= MembershipType.find(membership_type_id)
-  end
-
-  def new_memberships
-    if @new_memberships.blank?
-      @new_memberships = []
-
-      unless membership_ids.blank?
-        # Grab the old memberships and hash on id
-        old_memberships  = changing_memberships.reduce({}) do |all, o|
-          all[o.id.to_s] = o
-          all
-        end
-
-        # Make new memberships
-        @new_memberships = membership_ids.map do |old_membership_id|
-          old = old_memberships[old_membership_id]
-
-          membership            = Membership.for(membership_type)
-          membership.starts_at  = old.starts_at
-          membership.ends_at    = old.ends_at
-
-          membership.price      = membership.membership_type.price
-          membership.cart_price = price
-          membership.sold_price = price
-          membership.total_paid = old.total_paid + price
-          membership.member     = person.member
-
-          membership.changed_membership = old
-
-          membership
-        end
-      end
-    end
-    @new_memberships
-  end
-
-  def payment
-    unless @payment
-      @payment = Payment.create(payment_method, {credit_card: credit_card_info})
-      @payment.customer = person
-    end
-    @payment
-  end
-
-  def person
-    @person ||= Person.find(person_id)
-  end
-
-  def price
-    return nil unless @price
-    return 0 if comp?
-    @price
-  end
-
-  def price=(new_price)
-    new_price = new_price.to_i unless new_price.blank?
-    @price    = new_price
-  end
-
-  def save
-    return false unless valid?
-
-    Order.transaction do
-      expiration = 1.second.ago
-
-      # Complete checkout
-      success = checkout.finish
-
-      # Failure?
-      raise MembershipChange::Error unless success
-
-      # Expire old memberships
-      changing_memberships.each do |old|
-        old.adjust_expiration_to(expiration)
-      end
-    end
-    true
-  rescue MembershipChange::Error => e
-    payment.errors[:base].each do |msg|
-      errors.add(:base, msg)
-    end
-    false
-  end
-
-  def valid?
-    super && checkout.valid?
-  end
-
-  class Error < StandardError; end
-
-  class Cart < ::Cart
-  end
-
-  class Checkout < ::Checkout
-    def order_class
-      MembershipChange::Order
-    end
-  end
-
-  class Order < ::Order
-    before_create :set_details
-
-    def action_class
-      ChangeAction
-    end
-
-    def set_details
-      self.details = "Membership type change."
-    end
-  end
-end

data/app/models/membership_comp.rb

@@ -1,105 +0,0 @@
-class MembershipComp
-  QUEUE = "comp"
-
-  include ActiveModel::Conversion 
-  include ActiveModel::Validations
-  extend  ActiveModel::Naming
-
-  validate  :people_belong_to_this_org, 
-            :expiration_date_cannot_be_in_the_past,
-            :we_have_some_people
-  validates :number_of_memberships, numericality: true
-  validates :membership_type, presence: true
-
-  attr_accessor :people, 
-                :person_id,
-                :segment_id,
-                :search_id,
-                :organization, 
-                :membership_type, 
-                :number_of_memberships, 
-                :ends_at, 
-                :welcome_message, 
-                :send_email,
-                :notes,
-                :sold_price,
-                :benefactor
-
-  def initialize
-    self.people = []
-  end
-
-  def persisted?
-    false
-  end
-
-  def people_ids
-    people.nil? ? [] : people.collect(&:id)
-  end
-
-  def people_belong_to_this_org
-    people.each do |person|      
-      Rails.logger.info "FLARG #{person.organization.id} #{organization}"
-      if person.organization != organization
-        errors.add(:base, "Person does not belong to this organization. Please contact Artful.ly support if this problem persists.")
-      end
-    end
-  end
-
-  #
-  # Weird Rails/DJ bug where calling validate on membership_comp caused the errors
-  # to hang around. DJ would choke when Syck tried to deserialize the errors attr
-  # The error message was horrible and misleading (uninitialized constant Syck::Syck)
-  #
-  # It's probably because we're including ActiveModel::Validations on MembershipComp
-  #
-  def clear_errors
-    @errors = nil
-  end
-
-  def we_have_some_people
-    if people.blank?
-      errors.add(:base, "You haven't selected any people to receive memberships")
-    end
-  end
-
-  def expiration_date_cannot_be_in_the_past
-    if !ends_at.present?
-      errors.add(:base, "Please enter a membership expiration date")
-    end
-
-    if DateTime.parse(ends_at) < Date.today
-      errors.add(:base, "Membership expiration date can't be in the past")
-    end
-
-  rescue 
-    errors.add(:base, "Please enter a membership expiration date")
-  end
-
-  def award
-    return false unless valid?
-    MembershipCompJob.enqueue self
-  end
-
-  def perform
-    self.people.each do |person|
-      next if person.email.blank?
-      next if person.company?
-      memberships = []
-      self.number_of_memberships.to_i.times do
-        membership                  = Membership.for(self.membership_type)
-        membership.ends_at          = self.ends_at
-        membership.sold_price       = 0
-        membership.total_paid       = 0
-        membership.welcome_message  = self.welcome_message
-        membership.send_email       = self.send_email
-        membership.save
-        memberships << membership
-      end
-
-      comp = Comp.new(nil, [], memberships, person, self.benefactor)
-      comp.notes = self.notes
-      comp.submit
-    end
-  end
-end

data/app/models/membership_comp_job.rb

@@ -1,32 +0,0 @@
-class MembershipCompJob < Struct.new(:membership_comp)
-  QUEUE = "comp"
-
-  def self.enqueue(membership_comp)
-    job = MembershipCompJob.new
-
-    #
-    # Weird Rails/DJ bug where calling validate on membership_comp caused the errors
-    # to hang around. DJ would choke on when Syck tried to deserialize the errors attr
-    # The error message was horrible and misleading (uninitialized constant Syck::Syck)
-    #
-    # It's probably because we're including ActiveModel::Validations on MembershipComp
-    #
-    membership_comp.clear_errors
-    job.membership_comp = membership_comp
-
-    if run_now?
-      job.perform
-    else
-      Delayed::Job.enqueue job, :queue => QUEUE
-    end
-  end
-
-  def self.run_now?
-    Rails.env.test?
-  end
-
-  def perform
-    membership_comp.perform
-  end
-
-end

data/app/models/membership_sale_search.rb

@@ -1,18 +0,0 @@
-class MembershipSaleSearch
-  include SearchByDates
-
-  attr_reader :membership_type
-
-  def initialize(terms)
-    @organization    = terms[:organization]
-    @membership_type = terms[:membership_type]
-    @start           = start_with(terms[:start])
-    @stop            = stop_with(terms[:stop])
-
-    @results = yield(results) if block_given?
-  end
-
-  def results
-    @results ||= Order.membership_sale_search(self).select(&:has_membership?)
-  end
-end

data/app/models/pass.rb

@@ -1,197 +0,0 @@
-class Pass < ActiveRecord::Base
-  include Extendable
-  
-  belongs_to  :pass_type
-  belongs_to  :person
-  belongs_to  :organization
-  has_many    :tickets
-
-  before_save :adjust_ends_at
-  
-  EXPIRED_ERROR             = "Sorry! This pass has expired."
-  OUT_OF_TICKETS            = "Sorry! There are no tickets remaning on this pass."
-  OVER_EVENT_LIMIT          = "Sorry! This pass has already been redeemed for this event."
-  EVENT_NOT_ELIGIBLE        = "This pass is not eligible for some of the events in your cart."
-  SHOW_NOT_ELIGIBLE         = "This pass is not eligible for some of the shows in your cart."
-  TICKET_TYPE_NOT_ELIGIBLE  = "This pass is not eligible for some of the ticket types in your cart"
-  ORG_ERROR                 = "Sorry! This pass is not eligible for some of the tickets in your cart"
-
-  scope :not_expired, lambda { |time = DateTime.now| where("#{Pass.table_name}.ends_at > ?", time) }
-  scope :expired,     lambda { |time = DateTime.now| where("#{Pass.table_name}.ends_at < ?", time) }
-  scope :owned,       where('person_id is not null')
-
-  def self.for(pass_type)
-    new.tap do |pass|
-      pass.pass_type  = pass_type
-      pass.organization     = pass_type.organization
-      pass.price            = pass_type.price
-      pass.sold_price       = pass.price
-      pass.tickets_allowed  = pass_type.tickets_allowed
-      pass.pass_code        = new_pass_code
-      pass.starts_at        = pass_type.starts_at
-      pass.ends_at          = pass_type.ends_at
-    end
-  end 
-
-  def adjust_ends_at
-    self.ends_at = self.ends_at.end_of_day unless self.ends_at.blank?
-  end
-
-  def expire!
-    update_column(:ends_at, DateTime.now)
-  end
-
-  def cart_price
-    price
-  end
-
-  #
-  # We intentionally go to the DB here to avoid race conditions when
-  # applying a pass to the cart.
-  #
-  # Method could cause problems in very large N+1 situations. Where
-  # up-to-date accuracy isn't needed, Pass.includes(:tickets).tickets.length might be better
-  #
-  def tickets_purchased
-    Ticket.where(:pass_id => self.id).count
-  end
-
-  def realized_fee
-    self.pass_type.hide_fee? ? self.price * PassType::SERVICE_FEE : 0
-  end
-
-  def alive?
-    (tickets_allowed > tickets_purchased) && (starts_at < DateTime.now) && (ends_at > DateTime.now)
-  end
-
-  def expired?
-    ends_at < Time.now
-  end  
-
-  def refundable?
-    true
-  end
-
-  def exchangeable?
-    false
-  end
-
-  def returnable?
-    false
-  end
-
-  def self.new_pass_code(size=8)
-    # Avoid confusable characters like 1/L/I and 0/O
-    charset = %w{ 2 3 4 6 7 9 A C D E F G H J K M N P Q R T V W X Y Z}
-    (0...size).map{ charset.to_a[rand(charset.size)] }.join
-  end
-
-  def applies_to?(thing)
-    thing.applies_to_pass? self
-  end
-
-  def self.to_sentence(passes)
-    if passes.any?
-      pass_types = passes.collect(&:pass_type).uniq
-      if pass_types.length > 1
-        "multiple passes"
-      else
-        ActionController::Base.helpers.pluralize(passes.length, "#{passes.first.pass_type.passerize}")
-      end
-    else
-      "No passes"
-    end
-  end
-
-  def tickets_remaining_for(event)
-    @ept = EventsPassType.active
-                  .where(:organization_id => self.organization_id)
-                  .where(:event_id => event.id)
-                  .where(:pass_type_id => self.pass_type_id).first
-
-    return 0                    if @ept.nil?
-    return self.tickets_allowed if @ept.limit_per_pass.nil?
-    return @ept.limit_per_pass - event.tickets.where(:pass_id => self.id).count
-  end
-
-  def apply_pass_to_cart(cart)
-    Rails.logger.debug ("PASSES Applying pass [#{self.id}] to cart [#{cart.id}]")
-    cart.prepare_for_pass!
-
-    #the number of tickets remining for this pass. We go straight to the DB here
-    #to avoid a race condition on pass.tickets_remaining
-    tickets_remaining_on_pass = self.tickets_allowed - tickets_purchased
-    Rails.logger.debug ("PASSES [#{tickets_remaining_on_pass}] tickets remaining on this pass")
-
-    self.errors.add(:base, EXPIRED_ERROR)  and return if self.expired?
-    self.errors.add(:base, OUT_OF_TICKETS) and return if tickets_remaining_on_pass < 1
-
-    #The list of tickets w'eve applied this pass too
-    tickets_applied = []
-
-    #The list of tickets we rejected for being over the limit
-    tickets_rejected = []
-
-    over_event_limit = false
-    pass_errors = Set.new
-
-    transaction do
-
-      cart.applied_pass = self
-
-      cart.tickets.each do |ticket|
-        (pass_errors << EVENT_NOT_ELIGIBLE       and next) unless self.applies_to? (ticket.show.event)
-        (pass_errors << SHOW_NOT_ELIGIBLE        and next) unless self.applies_to? (ticket.show)
-        (pass_errors << TICKET_TYPE_NOT_ELIGIBLE and next) unless self.applies_to? (ticket.ticket_type)
-        (pass_errors << ORG_ERROR                and next) unless (self.organization == ticket.organization)
-
-        event = ticket.show.event
-        tickets_remaining_for_this_event = tickets_remaining_for(event)
-        Rails.logger.debug ("PASSES [#{tickets_remaining_for_this_event}] tickets remaining to event [#{event.id}]")
-        over_event_limit = true if tickets_remaining_for_this_event == 0
-
-        tickets_remaining = [tickets_remaining_on_pass, tickets_remaining_for_this_event].min
-        Rails.logger.debug ("PASSES [#{tickets_remaining}] tickets remaining after considering pass and event")
-
-        if tickets_remaining > 0
-          Rails.logger.debug ("PASSES adding pass [#{self.id}] to ticket [#{ticket.id}]")
-          ticket.pass = self
-          ticket.cart_price = 0
-          ticket.save
-          tickets_applied << ticket
-          tickets_remaining_on_pass = tickets_remaining_on_pass - 1
-          Rails.logger.debug ("PASSES Now only [#{tickets_remaining_on_pass}] tickets remaining on this pass")
-        else
-          Rails.logger.debug ("PASSES rejecting ticket [#{ticket.id}]")
-          tickets_rejected << tickets 
-        end
-      end
-
-      if tickets_rejected.length > 0 
-        str = ""
-        if tickets_applied.length == 0
-          str += "There are no tickets"
-        else
-          str += "Only #{ActionController::Base.helpers.pluralize(tickets_applied.length, 'ticket')}"
-          str += tickets_applied.length > 1 ? " were" : " was"
-        end
-
-        str += " remaining on this pass"
-        str += " for this event" if over_event_limit
-
-        if tickets_applied.length > 0
-          str += ". We've applied your pass to #{ActionController::Base.helpers.pluralize(tickets_applied.length, 'ticket')} and left the others in your cart."
-        end
-
-        pass_errors << str
-      end
-
-      pass_errors.each { |err| self.errors.add(:base, err) }
-
-      FeeCalculator.apply(FeeStrategy.new).to(cart)
-      cart.save
-    end
-
-
-  end
-end