brisk-bills 0.6.0

data/app/models/activity/labor/slimtimer.rb

@@ -0,0 +1,28 @@
+class Activity::Labor < ActiveRecord::Base
+  has_one :slimtimer_time_entry, :foreign_key => :activity_labor_id, :class_name => "::SlimtimerTimeEntry"
+end
+
+Activity.class_eval do
+
+  after_save do |record|
+    unless record.labor.nil? or record.labor.slimtimer_time_entry.nil? or record.labor.slimtimer_time_entry.slimtimer_task.nil?
+      st_task = record.labor.slimtimer_time_entry.slimtimer_task
+
+      ignore_auto_task, ignore_auto_client = Setting.grab :slimtimer_dont_autoassign_tasks, :slimtimer_dont_autoassign_clients
+        
+      ignore_auto_task = ignore_auto_task.to_re
+      ignore_auto_client = ignore_auto_client.to_re
+            
+      if (
+        !ignore_auto_task.match(st_task.name) and 
+        st_task.default_client_id != record.client_id and
+        (record.client and !ignore_auto_client.match(record.client.company_name))
+      )
+        st_task.default_client_id = record.client_id
+        st_task.save!
+      end
+    end
+  end
+
+  handle_extensions
+end

data/app/models/activity/material.rb

@@ -0,0 +1,16 @@
+class Activity::Material < ActiveRecord::Base
+  include ExtensibleObjectHelper
+  include ActivityTypeModelHelper
+  
+  validates_presence_of :label
+
+  def name
+    type_quick_namer '%s for %s on %s', label, client
+  end
+  
+  handle_extensions
+end
+
+Activity.class_eval do
+  has_one :material, :class_name => 'Activity::Material', :dependent => :destroy, :foreign_key => :activity_id
+end

data/app/models/activity/proposal.rb

@@ -0,0 +1,17 @@
+class Activity::Proposal < ActiveRecord::Base
+  include ExtensibleObjectHelper
+  include ActivityTypeModelHelper
+  
+  validates_presence_of :label
+  validates_presence_of :proposed_on
+
+  def name
+    type_quick_namer '%s for %s on %s', label, client
+  end
+  
+  handle_extensions
+end
+
+Activity.class_eval do
+  has_one :proposal, :class_name => 'Activity::Proposal', :dependent => :destroy, :foreign_key => :activity_id
+end

data/app/models/activity_type.rb

@@ -0,0 +1,2 @@
+class ActivityType < ActiveRecord::Base
+end

data/app/models/client.rb

@@ -0,0 +1,93 @@
+class Client < ActiveRecord::Base
+  include IsActiveModelHelper
+  
+  has_and_belongs_to_many :client_representatives, :join_table => 'client_representatives_clients', :uniq => true
+  
+  has_many :client_eventlogs
+  has_many :activities
+  has_many :invoices
+  has_many :payments
+  
+  has_many :employee_client_labor_rates, :class_name => 'EmployeeClientLaborRate', :dependent => :destroy
+  
+  has_many :client_financial_transactions
+  
+  before_destroy :ensure_not_referenced_on_destroy
+  
+  validates_presence_of :company_name
+
+  def name
+    self.company_name
+  end
+  
+  def uninvoiced_activities_balance( force_reload = false )
+    (attribute_present? :uninvoiced_activities_balance_in_cents and !force_reload) ?
+      Money.new(read_attribute(:uninvoiced_activities_balance_in_cents).to_i) :
+      (Activity.sum( Invoice::ACTIVITY_TOTAL_SQL, :conditions => ['client_id = ? AND is_published = ? AND invoice_id IS NULL',id, true] ) or 0.0)
+  end
+  
+  def balance( force_reload = false )
+    Money.new(
+      (attribute_present? :balance_in_cents and !force_reload) ?
+        read_attribute(:balance_in_cents).to_i :
+        Client.find(
+        :first, 
+        :select => [
+          'id',
+          'company_name',
+          '(
+           IF(charges.charges_sum_in_cents IS NULL, 0,charges.charges_sum_in_cents) - 
+           IF(deposits.payment_sum_in_cents IS NULL, 0, deposits.payment_sum_in_cents)
+          ) AS sum_difference_in_cents'
+        ].join(', '),
+        :joins => [
+          "LEFT JOIN(
+            SELECT invoices.client_id, SUM(#{Invoice::ACTIVITY_TOTAL_SQL}) AS charges_sum_in_cents 
+              FROM invoices 
+              LEFT JOIN activities ON activities.invoice_id = invoices.id 
+              GROUP BY invoices.client_id
+          ) AS charges ON charges.client_id = clients.id",
+          
+          'LEFT JOIN (
+            SELECT payments.client_id, SUM(payments.amount_in_cents) AS payment_sum_in_cents
+              FROM payments 
+              GROUP BY payments.client_id
+          ) AS deposits ON deposits.client_id = clients.id '
+        ].join(' '),
+        :conditions => [ 'clients.id = ?', id]
+        ).sum_difference_in_cents.to_i
+    ) unless id.nil?
+  end
+  
+  def ensure_not_referenced_on_destroy
+    errors.add_to_base "Can't destroy a referenced employee" and return false unless authorized_for? {:destroy}
+  end
+  
+  def authorized_for?(options)
+    case options[:action]
+      when :destroy
+        [Invoice, Payment, Activity].each{ |k| return false if k.count(:all, :conditions => ['client_id = ?', id] ) > 0 }
+
+        true
+      else
+        true
+    end
+  end
+  
+  def mailing_address
+    ret = []
+    
+    %w(name address1 address2).each do |f|
+      val = send(f.to_sym) and ( ret <<val if val.length )
+    end
+
+    ret << '%s%s %s' % [
+      (city.nil? or city.length == 0) ? '' : "#{city}, ", 
+      state, 
+      zip
+    ]
+
+    ret
+  end
+
+end

data/app/models/client_eventlog.rb

@@ -0,0 +1,5 @@
+class ClientEventlog < ActiveRecord::Base
+  belongs_to :client
+
+  validates_presence_of [:client_id, :description]
+end

data/app/models/client_representative.rb

@@ -0,0 +1,22 @@
+class ClientRepresentative < ActiveRecord::Base
+  include HasCredentialModelHelper
+
+  has_and_belongs_to_many :clients, :join_table => 'client_representatives_clients', :uniq => true
+  
+  validates_presence_of(
+    :first_name,
+    :unless => Proc.new { |cr| !cr.last_name.nil? and cr.last_name.length > 0 }, 
+    :message => " or Last name must be not be blank"
+  )
+  
+  def name
+    ret = String.new
+    
+    ret += self.first_name if !self.first_name.nil? and self.first_name.length > 0
+    
+    ret += (ret.length > 0) ? " #{self.last_name}" : self.last_name if !self.last_name.nil? and self.last_name.length > 0
+    
+    ret
+  end
+  
+end

data/app/models/credential.rb

@@ -0,0 +1,195 @@
+require "digest/sha2"
+
+class CredentialLockedOut < StandardError; end
+class CredentialDisabled < StandardError; end
+  
+class Credential < ActiveRecord::Base
+  validates_confirmation_of :password,  :if => :perform_password_validation?
+  validates_presence_of :password_hash, :if => :login_enabled, :message => "can't be blank if login is enabled"
+  
+  validates_uniqueness_of :email_address
+
+  attr_reader :password
+  
+  def password=(val)
+    @password = val
+    
+    self.password_hash = self.class.salt_and_hash(password) unless self.password.blank?
+  end
+  
+  belongs_to :user, :polymorphic => true
+
+  def self.salt_and_hash(password)
+    begin
+      @salt = Rails.configuration.authentication_salt
+    rescue
+      @salt = "Salt is missing - No Salt is a bad idea!"
+      logger.error @salt # cheeky?
+    end unless @salt
+
+    Digest::SHA256.hexdigest( "%s%s" % [password, @salt] )
+  end
+
+  def self.find_using_auth(email, password, find_at = Time.now)
+    credential = Credential.find(:first, :conditions => ['email_address = ?', email])
+
+    (credential and credential.accept_password?(password, find_at)) ? credential : nil
+  end
+
+  def self.find_by_email(email_address)
+    Credential.find :first, :conditions => ['email_address = ?', email_address]
+  end
+  
+  def self.humanize_duration_from_seconds(seconds)
+    # I did it this way so we can test easier
+    until_citation = [
+      (seconds/3600).floor,
+      ((seconds % 3600)/60).floor,
+      (seconds % 60)
+    ]
+
+    {0 => 'hour', 1 => 'minute', 2 => 'second'}.each_pair do |i, unit|
+      until_citation[i] = '%d %s' % [
+        until_citation[i], 
+        ((until_citation[i] > 1) ? unit.pluralize : unit)
+      ] if until_citation[i] and until_citation[i] > 0
+    end
+    
+    until_citation.reject!{|i| i.nil? or i == 0 }
+    
+    until_citation.join ' '
+  end
+  
+  def locked_out?(find_at)
+    account_lockout_threshold > 0 and
+    failed_login_at and
+    (failed_login_count % account_lockout_threshold) == 0 and 
+    locked_until(find_at) > 0
+  end
+  
+  def locked_until(find_at)
+    # NOTE: There's a multiplier effect here. So, if the lockout_threshold is 3, and there's been 12 unsuccessful logins
+    # we're not going to let them in for another 4*lockout_duration seconds
+
+    # How long we've been locked out for
+    been_locked_out_for = (find_at - failed_login_at).seconds
+    
+    lockout_multiplier = (failed_login_count / account_lockout_threshold).floor
+    
+    account_lockout_duration * lockout_multiplier - been_locked_out_for
+  end
+
+  def accept_password?(password, find_at)
+    password_security_transaction!(
+      password_hash == self.class.salt_and_hash(password), 
+      find_at
+    ) { self.reset_password_token = nil }
+  end
+  
+  def generate_reset_token!
+    raise_on_disabled
+    
+    char_pool = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
+
+    token = Array.new(32){char_pool[rand(char_pool.size-1)]}.join
+    
+    self.reset_password_token = token
+    reset_failed_login_fields
+    save!
+    
+    token
+  end
+  
+  def reset_password_by_token!(supplied_token, newpassword, find_at = Time.now)
+    password_security_transaction!(supplied_token == reset_password_token, find_at) do 
+      self.password = newpassword
+      self.reset_password_token = nil
+    end
+  end
+
+  def default_post_login_url_to
+    # NOTE: This should be different for non-admins when we get around to it ...
+    { :controller => 'admin/activities', :action => 'index' }
+  end
+
+  def is_request_permitted?(controller, action)
+    # NOTE: Highly rudimentary, but until we want to do the public side and proper ACLs, this will work.
+    user_type == 'Employee'
+  end
+
+  def self.guest_permitted?(controller,action)
+    # These are controller/actions that don't require auth to access. Probably these acl type questions should go into their own models eventually
+    controller == 'authentication'
+  end
+
+  private
+
+  def password_security_transaction!(success, find_at) 
+    # This is used by accept_password? and reset_password_by_token!
+    # Essentialy if conditional is true - then we reset our lockout counters and execute the block, if conditional is false we 
+    # increment failure counters. Regardless, we return the conditional status. These methods looked so similar I thought I'd DRY
+    # them out a bit
+    
+    raise_on_disabled
+
+    unless locked_out?(find_at)
+      if success
+        yield if block_given?
+        reset_failed_login_fields
+      else
+        bad_login(find_at)
+      end
+      
+      save! if changed?
+      
+      return true if success
+    end
+    
+    raise_on_locked_out(find_at)
+    
+    return false
+  end
+
+  def raise_on_disabled
+    raise CredentialDisabled, "Your account is currently disabled from logging in." if !login_enabled
+  end
+  
+  def raise_on_locked_out(find_at)
+    raise CredentialLockedOut, (
+      'Your account has been locked out due to too many unsuccessful login attempts. '+
+      "Please wait another #{self.class.humanize_duration_from_seconds(locked_until(find_at))} before trying again."
+    ) if locked_out?(find_at)
+  end
+
+  def reset_failed_login_fields
+    self.failed_login_count = 0
+    self.failed_login_at = nil
+  end
+  
+  def bad_login(find_at)
+    self.failed_login_count += 1
+    self.failed_login_at = find_at
+  end
+
+  def perform_password_validation?
+    self.new_record? ? true : !self.password.blank?
+  end
+  
+  # NOTE We do this to keep from pulling this information four times from the databaase during an authentication request
+  def account_lockout_threshold
+    grab_settings unless @lockout_threshold
+    @lockout_threshold
+  end
+  
+  def account_lockout_duration
+    grab_settings unless @lockout_duration
+    @lockout_duration
+  end
+  
+  def grab_settings
+    ( @lockout_threshold, @lockout_duration ) = Setting.grab :account_lockout_threshold, :account_lockout_duration
+    
+    @lockout_duration = @lockout_duration.to_i
+    @lockout_threshold = @lockout_threshold.to_i
+  end
+end

data/app/models/employee.rb

@@ -0,0 +1,49 @@
+class Employee < ActiveRecord::Base
+  include ExtensibleObjectHelper
+  include IsActiveModelHelper
+  include HasCredentialModelHelper
+
+  has_many :employee_client_labor_rates, :class_name => 'EmployeeClientLaborRate'
+
+  before_destroy :ensure_not_referenced_on_destroy
+
+  validates_presence_of [:first_name,:last_name, :email_address]
+  
+  validates_format_of [:first_name,:last_name], :with => /\A[a-z0-9 \-]+\Z/i
+  validates_format_of :email_address, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+  
+  validates_numericality_of :phone_extension, :allow_nil => true
+
+  def name
+    ret = String.new
+    
+    ret += first_name if !first_name.nil? and first_name.length > 0
+    
+    ret += (ret.length > 0) ? " #{last_name}" : last_name if !last_name.nil? and last_name.length > 0
+    
+    ret
+  end
+
+  def short_name
+    if first_name.length > 0 and last_name.length > 0
+      (first_name[0...1] + last_name).downcase
+    else
+      (first_name.length > 0) ? first_name.downcase : last_name.downcase
+    end
+  end
+  
+  def ensure_not_referenced_on_destroy
+    ( errors.add_to_base "Can't destroy a referenced employee" and return false ) unless authorized_for? :action => :destroy
+  end
+
+  def authorized_for?(options)
+    case options[:action]
+      when :destroy
+        ( Activity::Labor.count( :all, :conditions => ['employee_id = ?', id] ) > 0 ) ? false : true
+      else
+        true
+    end
+  end
+  
+  handle_extensions
+end

data/app/models/employee/labor.rb

@@ -0,0 +1,13 @@
+
+Employee.class_eval do
+
+  def labor_rate_for(client)
+    client_id ||= client.id if client.class.to_s == 'Client'
+    client_id ||= client.to_i if client.respond_to? :to_i
+    
+    raise StandardError, "Invalid Client" if client_id.nil?
+    
+    EmployeeClientLaborRate.find(:first, :conditions => ['employee_id = ? AND client_id = ?' , self.id , client_id ] )
+  end
+
+end