artfully_ose 1.2.0.beta.1 → 1.2.0.pre

data/app/helpers/relationships_helper.rb

@@ -1,26 +0,0 @@
-module RelationshipsHelper
-
-  def relationships_struct(person)
-    single = []
-    grouped = []
-    counts = person.relationships.group(:relation_id).count
-    counts.each do |id, count|
-      if count > 5
-        grouped << {:relation => id, :count => count}
-      else
-        single << id # Run person.in_relationships(relationships)
-      end
-    end
-
-    {
-      :starred => person.relationships.starred,
-      :single => single,
-      :grouped => grouped
-    }
-  end
-
-  def relationship_counts_for(person)
-    person.relationships.includes(:relation).group(:relation).count
-  end
-
-end

data/app/helpers/sales_helper.rb

@@ -1,29 +0,0 @@
-module SalesHelper
-  def door_list_sort(person)
-    result = if person.last_name.present?
-      person.last_name
-    elsif person.first_name.present?
-      person.first_name
-    else
-      person.email
-    end
-
-    result.downcase
-  end
-
-  def door_list_grouped_attribute(door_list_items, attr)
-    door_list_items.map {|d| d.send(attr)}.uniq.select {|n| n.present? }.to_sentence
-  end
-
-  def door_list_name_and_company(person)
-    result            = []
-    result           << content_tag(:strong, person.first_name) if person.first_name.present?
-    result           << " #{person.last_name}"                  if person.last_name.present?
-    if person.company_name.present?
-      result         << ", " if result.any?
-      result         << person.company_name
-    end
-
-    safe_join(result)
-  end
-end

data/app/helpers/searches_helper.rb

@@ -1,13 +0,0 @@
-module SearchesHelper
-  def search_membership_type_options(membership_types, selected=nil)
-    options = [
-      ['All Membership Types', -1]
-    ]
-
-    membership_types.each do |type|
-      options << [type.name, type.id]
-    end
-
-    options_for_select(options, selected)
-  end
-end

data/app/helpers/suggested_households_helper.rb

@@ -1,5 +0,0 @@
-module SuggestedHouseholdsHelper
-  def suggested_household_new_household_path(suggested_household)
-    new_household_path(:individuals => suggested_household.ids.split(','))
-  end
-end

data/app/mailers/pass_mailer.rb

@@ -1,17 +0,0 @@
-class PassMailer < ActionMailer::Base
-  layout "mail"
-
-  def pass_info_for(person, from, passes)
-    @person = person
-    @pass_summary = PassSummary.new(person.organization, passes)
-
-    options = Hash.new.tap do |o|
-      o[:to] = person.email
-      o[:from] = from
-      o[:subject] = "Your Passes"
-      o[:reply_to] = from
-    end
-
-    mail(options)
-  end
-end

data/app/models/actions/change_action.rb

@@ -1,13 +0,0 @@
-class ChangeAction < GetAction
-  def subtype
-    "Change"
-  end
-
-  def action_type
-    "Get"
-  end
-
-  def verb
-    "changed"
-  end
-end

data/app/models/actions/comp_action.rb

@@ -1,15 +0,0 @@
-class CompAction < GetAction
-  include ImmutableAction
-
-  def subtype
-    "Comp"
-  end
-
-  def action_type
-    "Get"
-  end
-  
-  def verb
-    "was comped"
-  end
-end

data/app/models/console_sale.rb

@@ -1,30 +0,0 @@
-module ConsoleSale  
-  class Checkout < ::Checkout 
-    def order_class
-      ConsoleSale::Order
-    end
-
-    def checkout_name
-      "sales console"
-    end
-  end
-
-  class Cart < ::Cart 
-    def calculate_fees(obj)
-      FeeCalculator.apply(ConsoleSale::FeeStrategy.new).to(self)
-    end
-  end
-  
-  class Order < ::Order  
-    def self.location
-      "Sales Console"
-    end
-  end
-
-  class FeeStrategy < ::FeeStrategy
-    def apply_to_cart(cart)
-      return if cart.is_a? BoxOffice::Cart
-      cart.items.each {|i| i.update_column(:service_fee, 0)}
-    end
-  end
-end

data/app/models/daily_membership_report.rb

@@ -1,50 +0,0 @@
-class DailyMembershipReport
-  attr_accessor :rows, :start_date, :organization, :lapsed_memberships
-  extend ::ArtfullyOseHelper  
-
-  def initialize(organization, date=nil)
-    @organization = organization
-    @start_date = (date || 1.day.ago).in_time_zone(@organization.time_zone).midnight
-    @end_date = @start_date + 1.day
-    orders = organization.orders.includes(:person, :items => :product)
-    orders = orders.csv_not_imported.after(@start_date).before(@end_date) || []
-
-    @rows = []
-    orders.each do |order|
-      next if order.memberships.empty?
-      next if !order.revenue_applies_to_range(@start_date, @end_date)
-
-      unique_memberships = order.memberships.collect{|item| item.product.membership_type.name}.uniq
-      unique_memberships.each do |membership_type_name|
-        @rows << Row.new(order.memberships.select {|item| item.product.membership_type.name == membership_type_name})        
-      end
-    end
-
-    @lapsed_memberships = organization.memberships.lapsed(@end_date, @start_date)
-  end
-
-  def send?
-    self.rows.any? || self.lapsed_memberships.any?
-  end
-
-  def total
-    @rows.collect(&:order).sum{|o| o.memberships.sum(&:total_price)}
-  end
-
-  class Row
-    attr_accessor :id, :details, :total, :person, :person_id, :order, :quantity, :membership
-    def initialize(items)
-      @order = items.first.order
-      @id = items.first.order.id
-      @membership = items.first.product.membership_type.name
-      @quantity = items.length
-      @total = DailyMembershipReport.number_to_currency(items.sum(&:price).to_f/100)
-      @person = items.first.order.person
-      @person_id = items.first.order.person.id
-    end
-
-    def calculate_total
-      DailyMembershipReport.number_to_currency(@order.memberships.sum(&:price).to_f/100)
-    end
-  end
-end

data/app/models/daily_pass_report.rb

@@ -1,48 +0,0 @@
-class DailyPassReport
-  attr_accessor :rows, :start_date, :organization
-  extend ::ArtfullyOseHelper  
-
-  def initialize(organization, date=nil)
-    @organization = organization
-    @start_date = (date || 1.day.ago).in_time_zone(@organization.time_zone).midnight
-    @end_date = @start_date + 1.day
-    orders = organization.orders.includes(:person, :items => :product)
-    orders = orders.csv_not_imported.after(@start_date).before(@end_date) || []
-
-    @rows = []
-    orders.each do |order|
-      next if order.passes.empty?
-      next if !order.revenue_applies_to_range(@start_date, @end_date)
-
-      unique_pass_types = order.passes.collect{|item| item.product.pass_type.name}.uniq
-      unique_pass_types.each do |pass_type_name|
-        @rows << Row.new(order.passes.select {|item| item.product.pass_type.name == pass_type_name})        
-      end
-    end
-  end
-
-  def send?
-    self.rows.any?
-  end
-
-  def total
-    @rows.collect(&:order).sum{|o| o.passes.sum(&:total_price)}
-  end
-
-  class Row
-    attr_accessor :id, :details, :total, :person, :person_id, :order, :quantity, :pass_type
-    def initialize(items)
-      @order = items.first.order
-      @id = items.first.order.id
-      @pass_type = items.first.product.pass_type.name
-      @quantity = items.length
-      @total = DailyPassReport.number_to_currency(items.sum(&:price).to_f/100)
-      @person = items.first.order.person
-      @person_id = items.first.order.person.id
-    end
-
-    def calculate_total
-      DailyPassReport.number_to_currency(@order.passes.sum(&:price).to_f/100)
-    end
-  end
-end

data/app/models/events_pass_type.rb

@@ -1,18 +0,0 @@
-class EventsPassType < ActiveRecord::Base
-  include OhNoes::Destroy
-
-  belongs_to :organization
-  belongs_to :event 
-  belongs_to :pass_type
-
-  attr_accessible :event, :pass_type, :excluded_shows, :ticket_types, :limit_per_pass
-
-  validates :event, :presence => true
-  validates :organization, :presence => true
-  validates :pass_type, :presence => true  
-
-  serialize :ticket_types, Set
-  serialize :excluded_shows, Set
-
-  scope :active, where(:active => true)
-end

data/app/models/ext/preprocessor.rb

@@ -1,7 +0,0 @@
-module Ext
-  module Preprocessor
-    def preprocess
-      true
-    end
-  end
-end

data/app/models/extendable.rb

@@ -1,6 +0,0 @@
-module Extendable
-  def adjust_expiration_to(new_ends_at)
-    self.ends_at = new_ends_at
-    self.save
-  end
-end

data/app/models/household.rb

@@ -1,61 +0,0 @@
-class Household < ActiveRecord::Base
-
-  attr_accessible :name, :address_attributes, :overwrite_member_addresses
-
-  has_one :address
-  has_many :individuals, :class_name => "Individual"
-  belongs_to :organization
-
-  accepts_nested_attributes_for :address, :allow_destroy => false
-
-  validates :name, :uniqueness => true
-
-  def lifetime_value
-    individuals.sum(:lifetime_value)
-  end
-
-  def lifetime_ticket_value
-    individuals.sum(:lifetime_ticket_value)
-  end
-
-  def lifetime_donations
-    individuals.sum(:lifetime_donations)
-  end
-
-  def lifetime_ticket_count
-    Ticket.where(:buyer_id => individuals.pluck(:id)).count
-  end
-
-  def lifetime_donations_count
-    individuals.includes(:orders).map { |i| i.orders.map { |o| o.donations.count }.sum }.sum
-  end
-
-  def notes
-    Note.where(:person_id => individuals.pluck(:id))
-  end
-
-  def actions
-    Action.where(:person_id => individuals.pluck(:id))
-  end
-
-  def addresses
-    Address.where(:person_id => individuals.pluck(:id))
-  end
-
-  def tags
-    ActsAsTaggableOn::Tagging.where(:taggable_type => "Person", :taggable_id => individuals.pluck(:id))
-  end
-
-  def update_member_addresses
-    return unless address.present?
-
-    individuals.each do |individual|
-      if individual.address.present?
-        individual.address.update_attributes(address.values_hash)
-      else
-        individual.address = address.dup
-      end
-    end
-  end
-
-end

data/app/models/household_suggester.rb

@@ -1,58 +0,0 @@
-class HouseholdSuggester
-
-  def initialize(org)
-    @org = org
-  end
-
-  def by_address
-    results = []
-    start = Time.now
-    people.each do |person|
-      break if (Time.now - start > 5 || results.count > 14)
-      next if person.address.nil?
-      next if already_found?(results, person)
-
-      a = person.address
-      matches = people.where(:addresses => {:address1 => a.address1, :address2 => a.address2}).where('addresses.zip like ?', a.zip)
-      results << matches.to_a if matches.count > 1
-    end
-
-    suggestions = []
-    results.each do |result|
-      existing = SuggestedHousehold.with_people(result)
-      unless existing.present? && existing.ignored
-        suggestions << SuggestedHousehold.find_or_create_with_people(result)
-      end
-    end
-
-    suggestions
-  end
-
-  def by_spouse
-    suggestions = [].to_set
-    start = Time.now
-    people.each do |person|
-      break if (Time.now - start > 5 || suggestions.count > 14)
-      person.relationships_of_relation("spouse to").each do |rel|
-        existing = SuggestedHousehold.with_people([rel.person, rel.other])
-        unless existing.present? && existing.ignored
-          suggestions << SuggestedHousehold.find_or_create_with_people([rel.person, rel.other])
-        end
-      end
-    end
-
-    suggestions.to_a
-  end
-
-  private
-
-  def already_found?(results, person)
-    results.any? do |matches|
-      matches.include?(person)
-    end
-  end
-
-  def people
-    @org.people.includes(:address).where('people.household_id is null')
-  end
-end

data/app/models/imports/memberships_import.rb

@@ -1,43 +0,0 @@
-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