artfully_ose 1.2.0.beta.1 → 1.2.0.pre

data/app/models/pass_sale_search.rb

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

data/app/models/pass_summary.rb

@@ -1,18 +0,0 @@
-class PassSummary
-  attr_accessor :organization, :passes, :rows
-  
-  def initialize(organization, passes)
-    @organization = organization
-    @passes = passes
-    @rows = {}
-    process_passes
-  end
-
-  def process_passes
-    @passes.each do |pass|
-      pass_type_array = @rows.fetch(pass.pass_type, [])
-      pass_type_array << pass
-      @rows[pass.pass_type] = pass_type_array
-    end
-  end
-end

data/app/models/pass_type.rb

@@ -1,46 +0,0 @@
-class PassType < ActiveRecord::Base
-  include Ext::Integrations::ServiceFee
-  include OhNoes::Destroy
-  extend ::ArtfullyOseHelper
-  
-  belongs_to :organization
-  has_many :passes
-
-  attr_accessible :name, :description, :hide_fee, :thanks_copy, :email_copy, :sales_start_at, :sales_end_at, 
-                  :on_sale, :price, :tickets_allowed, :starts_at, :ends_at
-
-  validates :name, :description, :price, :tickets_allowed, :starts_at, :ends_at, :presence => true
-
-  scope :storefront, where(:on_sale => true).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 :on_sale, where(:on_sale => true)
-  scope :not_ended, where('ends_at > ?', DateTime.now)
-
-  ALL_PASSES_STRING = "ALL PASSES"
-
-  comma do
-    name
-    description
-    price                      { |price| PassType.number_as_cents price }
-    tickets_allowed
-    passes 'Passes sold' do |p|
-      p.count
-    end
-    starts_at
-    ends_at
-    on_sale
-    sales_start_at
-    sales_end_at
-  end
-  
-  def sold
-    self.passes.select{ |p| p.person_id.present? }
-  end
-
-  def passerize
-    self.name.end_with?("Pass") ? self.name : self.name + " Pass"
-  end
-
-  def destroyable?
-    self.passes.empty?
-  end
-end

data/app/models/passes_report.rb

@@ -1,117 +0,0 @@
-class PassesReport
-  attr_accessor :pass_type, :header, :start_date, :end_date, :rows, :counts
-  attr_accessor :tickets_sold, :passes_sold, :total_tickets, :tickets_remaining, :original_price, :discounted
-  extend ::ArtfullyOseHelper
-
-  def pass_type_name
-    pass_type.try(:name) || PassType::ALL_PASSES_STRING
-  end
-
-  def initialize(organization, pass_type, start_date, end_date)  
-    self.pass_type = pass_type
-    self.start_date = start_date
-    self.end_date = end_date
-
-    @orders = find_orders
-
-    self.rows = []
-    @orders.each do |order|
-      self.rows << Row.new(order)
-    end
-
-    build_header
-
-    self.passes_sold      = count_passes_sold
-    self.total_tickets    = calculate_total_tickets
-    self.tickets_sold     = self.rows.inject(0) { |total, row| total + row.ticket_count}
-    self.tickets_remaining= self.total_tickets - self.tickets_sold
-    self.original_price   = self.rows.inject(0) { |total, row| total + row.original_price }
-    self.discounted       = self.rows.inject(0) { |total, row| total + row.discounted }
-  end
-
-  def calculate_total_tickets
-    @passes = Pass.owned
-    if self.pass_type.present?
-      @passes = @passes.where(:pass_type_id => self.pass_type.id)
-    end    
-
-    @passes.sum(:tickets_allowed)
-  end
-
-  def count_passes_sold
-    @items = Item.sold_or_comped.where(:product_type => "Pass")
-    @items = @items.joins("INNER join passes ON items.product_id = passes.id")
-    @items = @items.joins("INNER join pass_types ON passes.pass_type_id = pass_types.id")
-
-    if self.pass_type.present?
-      @items = @items.where("pass_types.id" => self.pass_type)
-    end
-
-    @items = @items.joins(:order)
-    @items = @items.where('orders.created_at > ?',self.start_date)  unless start_date.blank?
-    @items = @items.where('orders.created_at < ?',self.end_date)    unless end_date.blank?
-    @items.count
-  end
-
-  def find_orders
-    @orders = Order.includes(:person, :items => [:show => :event])
-                   .joins(:items)
-                   .joins("INNER join passes ON items.pass_id = passes.id")
-                   .joins("INNER join pass_types ON passes.pass_type_id = pass_types.id")
-                   .group('orders.id')
-                   .order('orders.created_at desc')
-
-    if pass_type.nil?               
-      @orders = @orders.where("pass_types.id is not null")
-    else
-      @orders = @orders.where("pass_types.id" => self.pass_type.id)
-    end
-
-    @orders = @orders.where('orders.created_at > ?',self.start_date)  unless start_date.blank?
-    @orders = @orders.where('orders.created_at < ?',self.end_date)    unless end_date.blank?
-    @orders
-  end
-
-  def build_header
-    self.header = pass_type_name
-    if self.start_date.blank? && self.end_date.blank? 
-      return
-    elsif self.start_date.blank?
-      self.header = self.header + " through #{I18n.localize(DateTime.parse(self.end_date), :format => :slashed_date)}"
-    elsif self.end_date.blank?
-      self.header = self.header + " since #{I18n.localize(DateTime.parse(self.start_date), :format => :slashed_date)}"
-    else
-      self.header = self.header + " from #{I18n.localize(DateTime.parse(self.start_date), :format => :slashed_date)} through #{I18n.localize(DateTime.parse(self.end_date), :format => :slashed_date)}"
-    end
-  end
-
-  class Row
-    attr_accessor :order, :show, :pass_type, :ticket_count, :original_price, :gross, :discounted
-
-    def initialize(order)
-      self.order = order
-      self.pass_type      = order.pass_codes.first.pass_type.name
-      self.show           = order.items_that_used_pass.first.show
-      self.original_price = order.items_that_used_pass.inject(0) { |total, item| total + item.original_price }
-      self.gross          = order.items_that_used_pass.inject(0) { |total, item| total + item.price }
-      self.discounted     = self.original_price - self.gross
-      self.ticket_count   = order.items_that_used_pass.length
-      self.ticket_count   = self.ticket_count * -1 if !order.items_that_used_pass.select(&:refund?).empty?
-    end
-
-    comma do
-      pass_type("Pass")
-      order("Order")          { |order| order.id }
-      order("Order Date")     { |order| order.created_at }
-      order("First Name")     { |order| order.person.first_name }
-      order("Last Name")      { |order| order.person.last_name }
-      order("Email")          { |order| order.person.email }
-      show("Event")           { |show| show.event.name }
-      ticket_count
-      original_price          { |original_price| DiscountsReport.number_as_cents original_price }
-      discounted              { |discounted| DiscountsReport.number_as_cents discounted }
-      gross                   { |gross| DiscountsReport.number_as_cents gross }
-    end
-
-  end
-end

data/app/models/payments/check_payment.rb

@@ -1,33 +0,0 @@
-class CheckPayment < ::Payment
-  payment_method :check
-  attr_accessor :amount, :check_number, :customer
-
-  def initialize(params = {})
-    @amount       = params[:amount]
-    @check_number = params[:check].try(:[], :number)
-    self.customer       ||= Person.new
-    build_customer_from(params)
-    build_address_from(params)
-  end
-
-  def requires_authorization?
-    false
-  end
-
-  def refund
-    self.errors.add(:base, "Check orders cannot be refunded.  Please return the tickets to inventory instead.")
-    false
-  end
-  
-  def requires_settlement?
-    false
-  end
-
-  def per_item_processing_charge
-    lambda { |item| 0 }
-  end
-
-  def transaction_id
-    nil
-  end
-end

data/app/models/relation.rb

@@ -1,27 +0,0 @@
-class Relation < ActiveRecord::Base
-  attr_accessible :description, :inverse,
-    :person_can_be_individual,
-    :person_can_be_company,
-    :other_can_be_individual,
-    :other_can_be_company
-
-  has_many :relationships
-  belongs_to :inverse, :class_name => 'Relation', :dependent => :destroy
-
-  def self.for_individual
-    where(:person_can_be_individual => true)
-  end
-
-  def self.for_company
-    where(:person_can_be_company => true)
-  end
-
-  def self.for_type(type)
-    send("for_#{type.downcase}")
-  end
-
-  def indefinite_article
-    %w(a e i o u).include?(description[0].downcase) ? 'an' : 'a'
-  end
-
-end

data/app/models/relation_builder.rb

@@ -1,32 +0,0 @@
-class RelationBuilder
-  def self.build_single(description, pi, pc, oi, oc)
-    ActiveRecord::Base.transaction do
-      relation = Relation.create(:description => description,
-                                 :person_can_be_individual => pi,
-                                 :person_can_be_company => pc,
-                                 :other_can_be_individual => oi,
-                                 :other_can_be_company => oc)
-      relation.update_attribute(:inverse_id, relation.id)
-      relation
-    end
-  end
-
-  def self.build(description, inverse_description, pi, pc, oi, oc)
-    ActiveRecord::Base.transaction do
-      relation = Relation.create(:description => description,
-                                 :person_can_be_individual => pi,
-                                 :person_can_be_company => pc,
-                                 :other_can_be_individual => oi,
-                                 :other_can_be_company => oc)
-
-      inverse = relation.create_inverse(:description => inverse_description,
-                                        :person_can_be_individual => oi,
-                                        :person_can_be_company => oc,
-                                        :other_can_be_individual => pi,
-                                        :other_can_be_company => pc,
-                                        :inverse => relation)
-      relation.update_attribute(:inverse_id, inverse.id)
-      relation
-    end
-  end
-end

data/app/models/relationship.rb

@@ -1,55 +0,0 @@
-class Relationship < ActiveRecord::Base
-  attr_accessible :person, :relation, :other, :starred, :inverse, :relation_id, :other_id
-
-  belongs_to :person
-  belongs_to :other, :class_name => 'Person'
-  belongs_to :inverse, :class_name => 'Relationship', :dependent => :destroy, :foreign_key => :inverse_id
-  has_one :inverse_relationship, :class_name => 'Relationship', :dependent => :destroy, :foreign_key => :inverse_id
-  belongs_to :relation
-
-  validates_with RelationshipValidator
-
-  after_create :assign_company_name
-
-  def assign_company_name
-    return unless relation.description == 'employed by'
-    person.company_name = other.company_name unless person.company_name.present?
-    person.save!
-  end
-
-  def self.starred
-    where(:starred => true)
-  end
-
-  def self.unstarred
-    where(:starred => false)
-  end
-
-  def self.of_relation(relation)
-    where(:relation => {:description => relation})
-  end
-
-  def unstar!
-    Relationship.transaction do
-      self[:starred] = false
-      inverse[:starred] = false
-      save!
-      inverse.save!
-    end
-  end
-
-  def star!
-    Relationship.transaction do
-      self[:starred] = true
-      inverse[:starred] = true
-      save!
-      inverse.save!
-    end
-  end
-
-  def ensure_inverse
-    create_inverse(:relation => relation.inverse, :person => other, :other => person, :inverse => self)
-    save
-  end
-
-end

data/app/models/relationship_builder.rb

@@ -1,12 +0,0 @@
-class RelationshipBuilder
-  def self.build(person, other, relation)
-    ActiveRecord::Base.transaction do
-      relationship = person.relationships.create(:other => other, :relation => relation)
-      relationship.save!
-      inverse = other.relationships.create(:other => person, :relation => relation.inverse, :inverse => relationship)
-      inverse.save!
-      relationship.update_attribute(:inverse_id, inverse.id)
-      relationship
-    end
-  end
-end

data/app/models/relationship_validator.rb

@@ -1,46 +0,0 @@
-class RelationshipValidator < ActiveModel::Validator
-  def validate(record)
-    validate_uniqueness(record)
-    validate_relation(record)
-  end
-
-  private
-
-  def validate_relation(record)
-
-    relation = record.relation
-
-    msg = "of type '#{relation.description}' cannot exist between #{record.person.class.name} and #{record.other.class.name}"
-
-    if record.person.company? && !relation.person_can_be_company
-      record.errors[:relation] = msg
-    end
-
-    if record.person.individual? && !relation.person_can_be_individual
-      record.errors[:relation] = msg
-    end
-
-    if record.other.company? && !relation.other_can_be_company
-      record.errors[:relation] = msg
-    end
-
-    if record.other.individual? && !relation.other_can_be_individual
-      record.errors[:relation] = msg
-    end
-  end
-
-  def validate_uniqueness(record)
-    identical = Relationship.where(:person_id => record.person_id,
-                                   :relation_id => record.relation_id,
-                                   :other_id => record.other_id)
-    unless record.id.nil?
-      identical = identical.where('id != ?', record.id)
-    end
-
-    if identical.count > 0
-      record.errors[:base] << "#{record.person} is already in a '#{record.relation.description}' relationship with #{record.other}"
-    end
-  end
-
-end
-

data/app/models/relationships_kit.rb

@@ -1,31 +0,0 @@
-class RelationshipsKit < Kit
-
-  acts_as_kit :admin_only => true do
-    self.configurable = false
-
-    state_machine do
-      state :cancelled, :enter => :kit_cancelled
-    end
-
-    when_active do |organization|
-      organization.can :access, :relationships
-    end
-  end
-
-  def friendly_name
-    "Relationships"
-  end  
-
-  def pitch
-    "Track Relationships!"
-  end
-
-  def configured?
-    true
-  end
-
-  def configured!
-    settings[:membership_state] = "configured"
-    save
-  end
-end