artfully_ose 1.2.0 → 1.3.0.pre1

data/app/models/ticket/locker.rb

@@ -20,12 +20,18 @@ module Ticket::Locker
       tickets
     end
 
+    #
+    # Unlock all tickets in tickets. The cart will also be rejected so that the app can surface a message 
+    # to the user that their cart has been modified.
     #
     # We pass cart so that we can ensure we're expiring the right transaction. The ticket could have moved
     # carts since the job was queued.
     #
     # If we come along and expire it, the patron will be bitter.
     #
+    # Calling this method directly is vastly discouraged. Please use ExpireTicketJob.new.perform
+    # to expire tickets.
+    #
     def unlock(tickets, cart)
       
       Ticket.where(:id => tickets)
@@ -40,6 +46,25 @@ module Ticket::Locker
                           :discount_id    => nil
                         })
     end
+
+    def any_processing?(tickets)
+      Ticket.where(:id => tickets)
+            .where("processing_at is not null")
+            .any?
+    end
+
+    def processing!(tickets, cart)
+      Ticket.where(:id => tickets)
+            .where(:cart_id => cart)
+            .uncommitted
+            .update_all({ :processing_at => DateTime.now })      
+    end
+
+    def unprocessing!(tickets, cart)
+      Ticket.where(:id => tickets)
+            .where(:cart_id => cart)
+            .update_all({ :processing_at => nil }) 
+    end
   end
 
   #

data/app/models/ticket_summary.rb

@@ -10,7 +10,7 @@ class TicketSummary
   end
   
   def <<(ticket)
-    row_for_this(ticket.show) << ticket
+    row_for_this(ticket.show) << ticket unless (ticket.nil? || ticket.ticket_type.nil?)
   end
   
   class TicketSummary::Row

data/app/models/ticket_type.rb

@@ -1,4 +1,6 @@
 class TicketType < ActiveRecord::Base
+  include OhNoes::Destroy
+
   belongs_to  :section
   belongs_to  :show
   belongs_to  :membership_type
@@ -6,12 +8,13 @@ class TicketType < ActiveRecord::Base
   has_many    :tickets
 
   after_save  { self.chart.upgrade_event unless self.chart.nil? }
-  attr_accessible :name, :price, :limit, :description, :storefront, :box_office, :members, 
-                  :membership_type_id, :tickets_per_membership, :member_ticket
+  attr_accessible :name, :price, :limit, :description, :storefront, :box_office, :members,
+                  :membership_type_id, :tickets_per_membership, :member_ticket, :receipt_details
 
   before_save :clear_membership_type_id
 
   validates :membership_type_id,    :presence => true, :if => :member_ticket?
+  validates_presence_of :name
 
   def as_json(options = {})
     {
@@ -78,6 +81,11 @@ class TicketType < ActiveRecord::Base
   end
 
   def self.price_to_cents(price_in_dollars)
+    price_in_dollars ||= ""
+
+    #eliminate any $ or ,
+    price_in_dollars.gsub!(/[\$\,]/,"")
+
     (price_in_dollars.to_f * 100).to_i
   end
 
@@ -126,6 +134,10 @@ class TicketType < ActiveRecord::Base
     tickets.select {|t| t.comped?}
   end
 
+  def destroyable?
+    committed.none?
+  end
+
   def self.set_show(show)
     TicketType.joins(:section => :chart).where('charts.id = ?', show.chart_id).update_all(:show_id => show.id)
   end

data/app/models/user.rb

@@ -14,14 +14,37 @@ class User < ActiveRecord::Base
   has_many :user_memberships
   has_many :organizations, :through => :user_memberships
 
+  serialize :cas_extra_attributes
+
   scope :logged_in_more_than_once, where("users.sign_in_count > 1")
 
+  searchable do
+    text :first_name
+    text :last_name
+    text :email
+
+    text :full_name do
+      (first_name || "") + " " + (last_name || "")
+    end
+
+    text :organizations do
+      organizations.map {|org| org.name }.join(" ")
+    end
+  end
+  include Ext::DelayedIndexing
+
   def self.generate_password
     Devise.friendly_token
   end
 
-  # Setup accessible (or protected) attributes for your model
-  attr_accessible :email, :password, :password_confirmation, :remember_me, :user_agreement, :newsletter_emails, :first_name, :last_name, :user_memberships_attributes
+  delegate :can?, :cannot?, :to => :ability
+  def ability
+    Ability.new(self)
+  end
+
+  attr_accessible :email, :password, :password_confirmation, :remember_me, 
+                  :user_agreement, :newsletter_emails, :first_name, :last_name, 
+                  :user_memberships_attributes, :fa_user_id, :cas_extra_attributes
 
   def is_in_organization?
     @is_in_organization ||= !!(user_memberships.any? && ! user_memberships.first.organization.new_record?)
@@ -32,7 +55,11 @@ class User < ActiveRecord::Base
   end
 
   def membership_in(organization)
-    user_memberships.where(:organization_id => organization.id).limit(1).first
+    if @membership && organization.id == @membership.organization_id
+      @membership
+    else
+      user_memberships.where(:organization_id => organization.id).limit(1).first
+    end
   end
 
   def self.like(query = "")
@@ -57,4 +84,16 @@ class User < ActiveRecord::Base
       "No Name ##{id}"
     end
   end
+
+  def permission_in(organization)
+    membership_in(organization).try(:role_title)
+  end
+
+  def has_permission_in?(role, organization)
+    !!(membership_in(organization).try("#{Permission.database_column_for(role)}"))
+  end
+
+  def is_org_admin_of(organization)
+    !!(membership_in(organization) && membership_in(organization).organization_administrator?)
+  end
 end

data/app/models/user_membership.rb

@@ -1,6 +1,7 @@
 class UserMembership < ActiveRecord::Base
   # Be careful here!  :user needs to come out of this if we ever support update action on memberships controller
-  attr_accessible :user, :organization_attributes
+  attr_accessible :user, :organization_attributes, 
+                  :organization_administrator, :manager, :general_associate, :box_office_associate
 
   belongs_to :user
   belongs_to :organization
@@ -9,6 +10,47 @@ class UserMembership < ActiveRecord::Base
 
   validates :user_id, :uniqueness => {:scope => :organization_id}
 
+  #
+  # These methods all depend on one-to-one user roles situation
+  #
+  def role_title
+    return Permission::ORGANIZATION_ADMINISTRATOR if organization_administrator?
+    return Permission::MANAGER                    if manager?
+    return Permission::GENERAL_ASSOCIATE          if general_associate?
+    return Permission::BOX_OFFICE_ASSOCIATE       if box_office_associate?
+  end
+
+  def self.sort_by_permission(user_memberships)
+    @sorted_user_memberships = []
+    @sorted_user_memberships << user_memberships.select(&:organization_administrator)
+    @sorted_user_memberships << user_memberships.select(&:manager)
+    @sorted_user_memberships << user_memberships.select(&:general_associate)
+    @sorted_user_memberships << user_memberships.select(&:box_office_associate)
+    @sorted_user_memberships.flatten
+  end
+
+  def self.set_role(user, organization, new_role)    
+    @user_membership = UserMembership.where(:user_id => user.id, :organization_id => organization.id).first
+
+    return false if @user_membership.nil?
+
+    @user_membership.transaction do
+      return @user_membership.set_role!(new_role)
+    end
+  end
+
+  #
+  # Pass a Permission::ORGANIZATION_ADMINISTRATOR role or the like
+  #
+  def set_role!(new_role)
+    ["organization_administrator", "manager", "general_associate", "box_office_associate"].each do |role|
+      self.send("#{role}=", false)
+    end
+    new_role = Permission.database_column_for(new_role)
+    self.send("#{new_role}=", true)
+    self.save
+  end
+
   #
   # Will promote new_owner to admin and demote any other owners
   #
@@ -19,9 +61,21 @@ class UserMembership < ActiveRecord::Base
     return false if @user_membership.nil?
 
     @user_membership.transaction do
-      UserMembership.where(:organization_id => organization.id).update_all(:owner => false)
+      if organization.administrator_limited?
+        #Make all org admins a manager
+        UserMembership.where(:organization_id => organization.id)
+          .where(Permission.database_column_for(Permission::ORGANIZATION_ADMINISTRATOR).to_sym => true)
+          .update_all(Permission.database_column_for(Permission::MANAGER).to_sym => true)
+        
+        #Turn off all admins if this organization is limited to 1 admin
+        UserMembership.where(:organization_id => organization.id)
+          .update_all(Permission.database_column_for(Permission::ORGANIZATION_ADMINISTRATOR).to_sym => false)
+      end
+
       @user_membership.reload
-      @user_membership.owner  = true
+      
+      #Make this user a manager
+      @user_membership.set_role!(Permission::ORGANIZATION_ADMINISTRATOR)
       return @user_membership.save
     end
   end

data/app/models/valuation/lifetime_donations.rb

@@ -25,8 +25,8 @@ module Valuation
     #
     def calculate_lifetime_donations
       self.lifetime_donations = 0
-      lifetime_orders.each do |o|
-        o.donations.each { |i| self.lifetime_donations = self.lifetime_donations + i.total_price}
+      lifetime_orders.pledge(false).each do |o|
+        o.donations.reject { |i| i.dead?}.each { |i| self.lifetime_donations = self.lifetime_donations + i.total_price}
       end
       save
       self.lifetime_donations

data/app/models/valuation/lifetime_pledges.rb

@@ -0,0 +1,35 @@
+module Valuation
+
+  #
+  # Anything with a :lifetime_pledges column and has_many pledges can use this module.
+  #
+  module LifetimePledges
+    extend ActiveSupport::Concern
+    
+    #
+    # Includers can define a method called lifetime_pledges which
+    # will override this method.
+    #
+    # lifetime_pledges should return the pledges that this model wants to include in the calculation
+    #  
+    def lifetime_orders
+      orders
+    end
+    
+    #
+    # Calculate the lifetime pledges of this model by summing the price of all pledges
+    # attached to orders attached to this person.  Save the pledges in lifetime_pledges.
+    # Return the total
+    #
+    # This could be done (probably faster) in a single sql SELECT SUM suery 
+    #
+    def calculate_lifetime_pledges
+      self.lifetime_pledges = 0
+      lifetime_orders.pledge.each do |o|
+        self.lifetime_pledges = self.lifetime_pledges + (o.fully_paid? ? 0 : o.outstanding_amount)
+      end
+      save
+      self.lifetime_pledges
+    end
+  end
+end

data/app/models/valuation/lifetime_value.rb

@@ -22,7 +22,11 @@ module Valuation
     # Return the value
     #
     def calculate_lifetime_value
-      self.lifetime_value = Item.where(:order_id => self.lifetime_orders).sum(Item.total_price_sql_sum).to_i
+      self.lifetime_value = Item.
+              joins('LEFT JOIN donations ON donations.id = items.product_id').
+              where('(donations.pledge = ? OR items.product_type != ?)',  false, 'Donation').
+              where(:order_id => self.lifetime_orders).sum(Item.total_price_sql_sum).to_i
+      self.lifetime_value = self.lifetime_value + soft_credits.sum('amount').to_i * 100
       self.save(:validate => false)
       self.lifetime_value
     end

data/app/models/valuation_query.rb

@@ -0,0 +1,109 @@
+class ValuationQuery 
+  attr_accessor :people, :organization, :starts_at, :ends_at, :stats
+
+  def self.run_for(options={})
+    valuation = ValuationQuery.new
+
+    valuation.people          = Array.wrap(options[:people])
+    valuation.organization    = options[:organization]
+    valuation.starts_at       = options[:starts_at]
+    valuation.ends_at         = options[:ends_at]
+
+    #
+    # The plan: select org averages, then select all individual counts and averages
+    #
+
+    #
+    # TODO: This should be run in a nightly job and saved to the org row in the db
+    # Also note that this only excludes people.first because we can't run a NOT IN ()
+    # 
+    org_average_sql = "select avg(ticket_sum) as tickets_avg , " +
+    "avg(donation_sum) as donations_avg , " +
+    "avg(pass_sum) as passes_avg , " +
+    "avg(membership_sum) as memberships_avg " +
+    "from ( " +
+    "(SELECT  " +
+    "SUM(case when items.product_type='Ticket' then items.price else null end) AS ticket_sum,  " +
+    "SUM(case when items.product_type='Donation' then items.price else null end) AS donation_sum, "  +
+    "SUM(case when items.product_type='Pass' then items.price else null end) AS pass_sum,  " +
+    "SUM(case when items.product_type='Membership' then items.price else null end) AS membership_sum, "  +
+    "orders.person_id  " +
+    "FROM `items`  " +
+    "INNER JOIN orders on orders.id=items.order_id " +
+    "WHERE `orders`.`person_id` != #{valuation.people.first.id}  " +
+    "AND `orders`.`organization_id` = #{valuation.organization.id}  " +
+    "AND items.state NOT IN ('refunded', 'refund', 'exchanged', 'returned') "
+    
+    if valuation.starts_at.present?
+      org_average_sql += "AND `orders`.`revenue_applies_at` >= '#{valuation.starts_at.to_formatted_s(:db)}'  "
+    end
+
+    if valuation.ends_at.present?
+      org_average_sql += "AND `orders`.`revenue_applies_at` <= '#{valuation.ends_at.to_formatted_s(:db)}'   "
+    end
+    org_average_sql += "GROUP BY person_id)  "
+    org_average_sql += "something) "
+    org_average_result = ActiveRecord::Base.connection.select_all(org_average_sql)
+
+    #
+    # Sum and count
+    #
+    sum_and_count_sql = "select " +
+    "count(case when i.product_type='Ticket' then 1 else null end) as tickets_count, " +
+    "sum(case when i.product_type='Ticket' then i.price else null end) as tickets_total, " +
+    "count(case when i.product_type='Donation' then i.price else null end) as donations_count, " +
+    "sum(case when ((i.product_type='Donation') && (i.deleted_at IS NULL)) then i.price else null end) as donations_total, " +
+    "count(case when i.product_type='Pass' then i.price else null end) as passes_count, " +
+    "sum(case when i.product_type='Pass' then i.price else null end) as passes_total, " +
+    "count(case when i.product_type='Membership' then i.price else null end) as memberships_count, " +
+    "sum(case when i.product_type='Membership' then i.price else null end) as memberships_total " +
+    "from items i " +
+    "inner join orders o on i.order_id=o.id " +
+    "where o.person_id in (#{valuation.people.collect(&:id).join(",")}) " +
+    "AND i.state NOT IN ('refunded', 'refund', 'exchanged', 'returned') "
+    if valuation.starts_at.present?
+      sum_and_count_sql += "AND `o`.`revenue_applies_at` >= '#{valuation.starts_at.to_formatted_s(:db)}'  "
+    end
+
+    if valuation.ends_at.present?
+      sum_and_count_sql +="AND `o`.`revenue_applies_at` <= '#{valuation.ends_at.to_formatted_s(:db)}'   "
+    end
+    sum_and_count_result = ActiveRecord::Base.connection.select_all(sum_and_count_sql)
+
+    #
+    # Pack up valuation
+    #
+    valuation.stats = {}
+
+    [:tickets, :donations].each do |product, proc|
+      stats_hash = {}
+      stats_hash[:pretty_name]        = product.to_s.humanize
+      stats_hash[:org_average_total]  = org_average_result.first["#{product}_avg"] || 0
+      stats_hash[:individual_total]   = sum_and_count_result.first["#{product}_total"] || 0
+      stats_hash[:individual_count]   = sum_and_count_result.first["#{product}_count"] || 0
+      valuation.stats[product] = stats_hash
+    end
+
+    {:passes => :passes,:memberships => :membership}.each do |product, kit|
+      if valuation.organization.has_kit? kit
+        stats_hash = {}
+        stats_hash[:pretty_name]        = product.to_s.humanize
+        stats_hash[:org_average_total]  = org_average_result.first["#{product}_avg"] || 0
+        stats_hash[:individual_total]   = sum_and_count_result.first["#{product}_total"] || 0
+        stats_hash[:individual_count]   = sum_and_count_result.first["#{product}_count"] || 0
+        valuation.stats[product] = stats_hash
+      end
+    end
+
+    valuation.stats[:total] = {
+      :individual_total  =>  valuation.stats.map {|k,v| valuation.stats[k][:individual_total] || 0 }.sum,
+      :org_average_total => valuation.stats.map {|k,v| valuation.stats[k][:org_average_total] || 0 }.sum,
+      :org_people_count  =>  valuation.organization.people.count
+    }
+
+    valuation.stats[:starts_at] = valuation.starts_at
+    valuation.stats[:stops_at]  = valuation.ends_at
+
+    valuation
+  end
+end

data/app/models/venue.rb

@@ -13,6 +13,14 @@ class Venue < ActiveRecord::Base
   after_save :run_geocode, :if => :address1_changed?
   after_save :refresh_show_stats, :if => :time_zone_changed?
   
+  def name_and_address_as_string
+    string = ''
+    string = self.name 
+    string += " -- " if (self.name? && self.address_as_string.present?)
+    string += address_as_string
+    string
+  end
+
   def address_as_string
     street_as_string + " " + city_state_zip_as_string
   end

data/app/views/actions/_action.html.haml

@@ -2,7 +2,7 @@
   %td.starred.starable{"data-person-id" => @person.id, "data-type" => 'action', "data-action-id" => action.id, :class => (action.starred? ? "active" : "not-active") }
     ✭
   %td
-    = action.occurred_at.strftime("%D") unless action.occurred_at.nil?
+    = action.occurred_at_local_to_organization.strftime("%D") unless action.occurred_at.nil?
   %td.icon
     = link_to action.action_type, '#', :class => "btn action-icon #{action.action_type.downcase}-icon", :onclick => "return false;"
 

data/app/views/actions/_form.html.haml

@@ -7,7 +7,7 @@
         = action_type_button(action, 'say', 'Said', "Record a communication #{target} initiated.")
         = action_type_button(action, 'go', 'Went', "Record when #{target} attended an event.")
         = action_type_button(action, 'do', 'Helped', "Record when #{target} volunteered")
-        = link_to 'Gave', new_contribution_path("contribution[person_id]" => target.id), :class => "btn edit-order-link weak", "data-remote" => "true"
+        = link_to 'Gave', new_contribution_path("contribution[person_id]" => target.id), :class => "btn edit-order-link weak"
       -else
         = action_type_button(action, 'hear', 'Heard', "Record a communication you sent to this group")
         = action_type_button(action, 'say', 'Said', "Record a communication this group initiated")
@@ -23,11 +23,11 @@
     .dollar-inputs.input-prepend{:style => (action.new_record? ? 'display:none;' : '')}
       %span.add-on $
       = form.text_field :dollar_amount, :placeholder => 'donation value', :class => 'input-small'
-
   - details_text_area_options = {:size => "125x5", :class => 'input-xxlarge', :placeholder => "Select an action type above..."}
   - details_text_area_options = details_text_area_options.merge(:disabled => 'disabled') if action.details.blank?
   = form.text_area :details, details_text_area_options
   - unless action.new_record?
+    %p= "Creator: #{action.creator || 'System'}"
     = link_to "delete", "#delete-confirm-action-#{action.id}", :class => "delete-confirm-link delete-with-trash", "data-toggle" => "modal"
   - if action.new_record?
     = form.submit "Save", :class => "btn btn-primary artfully-tooltip new-action-save", :rel => "tooltip", :data => {"original-title" => "Pick an action type before saving.", :trigger => "hover", :placement => "left"}