xrono 1.0.0

data/app/models/contact.rb

@@ -0,0 +1,10 @@
+class Contact < ActiveRecord::Base
+  belongs_to :client
+
+  validates_presence_of :first_name
+  validates_presence_of :last_name
+  validates_presence_of :email_address
+
+  scope :for_client, lambda{ |client| where(:client_id => client.id)}
+  scope :receives_email, where(:receives_email => true)
+end

data/app/models/data_vault.rb

@@ -0,0 +1,6 @@
+class DataVault < ActiveRecord::Base
+  has_paper_trail
+  attr_encrypted :data, :key => "SECRET!", :attribute => :encrypted_data
+
+  belongs_to :data_vaultable, :polymorphic => true
+end

data/app/models/file_attachment.rb

@@ -0,0 +1,8 @@
+class FileAttachment < ActiveRecord::Base
+  belongs_to :project
+  belongs_to :client
+  belongs_to :ticket
+
+  has_attached_file :attachment_file
+  validates_attachment_presence :attachment_file
+end

data/app/models/project.rb

@@ -0,0 +1,76 @@
+class Project < ActiveRecord::Base
+  include GuidReferenced
+  acts_as_commentable
+  acts_as_authorization_object
+  acts_as_taggable
+
+  github_concern :repo => :git_repo_name
+
+  belongs_to :client
+  has_many :tickets
+  has_many :comments, :as => :commentable
+  has_many :file_attachments
+  has_one :data_vault, :as => :data_vaultable
+
+  validates_presence_of :name
+  validates_presence_of :client_id
+  validates_uniqueness_of :name, :scope => :client_id
+
+  after_create :create_data_vault
+
+  scope :sort_by_name, order('name ASC')
+  scope :for_client,    lambda {|client|    where :client_id => client.id }
+  scope :for_client_id, lambda {|client_id| where :client_id => client_id }
+  scope :incomplete, where(:completed => false)
+  scope :complete, where(:completed => true)
+  scope :with_git_repos, where(arel_table[:git_repo_url].not_eq(nil))
+
+  scope :for_user, lambda{|user|
+    joins("INNER JOIN roles r ON r.authorizable_type='#{model_name}' AND r.authorizable_id=projects.id").joins("INNER JOIN roles_users ru ON ru.role_id = r.id").joins("INNER JOIN users u ON ru.user_id = u.id").where("ru.user_id = #{user.id}")
+  }
+
+  scope :for_user_and_role, lambda{|user, role|
+    joins("INNER JOIN roles r ON r.authorizable_type='#{model_name}' AND r.authorizable_id=projects.id").joins("INNER JOIN roles_users ru ON ru.role_id = r.id").joins("INNER JOIN users u ON ru.user_id = u.id").where("ru.user_id = #{user.id} AND r.name = '#{role}'")
+  }
+
+  def uninvoiced_hours
+    WorkUnit.for_project(self).not_invoiced.sum(:effective_hours)
+  end
+
+  def hours
+    WorkUnit.for_project(self).sum(:effective_hours)
+  end
+
+  def hours_this_month
+    WorkUnit.for_project(self).scheduled_between(Time.zone.now.beginning_of_month, Time.zone.now.end_of_month).sum(:effective_hours)
+  end
+
+  def hours_this_week
+    WorkUnit.for_project(self).scheduled_between(Time.zone.now.beginning_of_week, Time.zone.now.end_of_week).sum(:effective_hours)
+  end
+
+  def work_units
+    WorkUnit.for_project(self)
+  end
+
+  def to_s
+    if new_record?
+      I18n.t(:new_project)
+    else
+      name
+    end
+  end
+
+  def allows_access?(user)
+    accepts_roles_by?(user) || user.admin?
+  end
+
+  def files_and_comments
+    [comments, file_attachments].flatten.sort_by {|x| x.created_at}
+  end
+
+  private
+  def create_data_vault
+    self.data_vault = DataVault.create(:data_vaultable => self)
+  end
+end

data/app/models/role.rb

@@ -0,0 +1,3 @@
+class Role < ActiveRecord::Base
+  acts_as_authorization_role :join_table_name => :roles_users
+end

data/app/models/roles_user.rb

@@ -0,0 +1,4 @@
+class RolesUser < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :role
+end

data/app/models/site_settings.rb

@@ -0,0 +1,4 @@
+class SiteSettings < ActiveRecord::Base
+  has_attached_file :site_logo, :default_url => '/assets/logo_97x40.png'
+  belongs_to :client
+end

data/app/models/ticket.rb

@@ -0,0 +1,85 @@
+class Ticket < ActiveRecord::Base
+  include GuidReferenced
+  acts_as_commentable
+  belongs_to :project
+  has_many :work_units
+  has_many :file_attachments
+
+  validates_presence_of :project_id
+  validates_presence_of :name
+
+  scope :for_client,     lambda{|client|     joins({:project => [:client]}).where("clients.id = ?", client.id) }
+  scope :for_project,    lambda{|project|    where(:project_id => project.id) }
+  scope :for_projects,   lambda{|projects|   where(:project_id => projects.map(&:id)) }
+  scope :for_project_id, lambda{|project_id| where :project_id => project_id }
+  scope :sort_by_name,   order('name ASC')
+  scope :for_state, lambda { |state| where(:state => state) }
+  scope :incomplete, :conditions => ["completed = ?", false]
+  scope :complete, :conditions => ["completed = ?", true]
+
+  scope :for_user, lambda{|user|
+    joins("INNER JOIN projects p ON p.id=tickets.project_id").joins("INNER JOIN roles r ON r.authorizable_type='Project' AND r.authorizable_id=p.id").joins("INNER JOIN roles_users ru ON ru.role_id = r.id").where("ru.user_id = ?", user.id)
+  }
+
+  scope :for_user_and_role, lambda{|user, role|
+    joins("INNER JOIN projects p ON p.id=tickets.project_id").joins("INNER JOIN roles r ON r.authorizable_type='Project' AND r.authorizable_id=p.id").joins("INNER JOIN roles_users ru ON ru.role_id = r.id").where("ru.user_id = #{user.id} AND r.name = '#{role}'")
+  }
+
+  scope :for_repo_and_branch, lambda{|repo,branch|
+    joins("INNER JOIN projects p ON p.id=tickets.project_id").where("p.git_repo_name = '#{repo}' and tickets.git_branch = '#{branch}'")
+  }
+
+  scope :for_repo_url_and_branch, lambda{|repo,branch|
+    joins("INNER JOIN projects p ON p.id=tickets.project_id").where("p.git_repo_url = '#{repo}' and tickets.git_branch = '#{branch}'")
+  }
+
+  def client
+    project.client
+  end
+
+  def to_s
+    name
+  end
+
+  def hours
+    work_units.sum(:effective_hours)
+  end
+
+  def unpaid_hours
+    work_units.unpaid.sum(:effective_hours)
+  end
+
+  def uninvoiced_hours
+    work_units.not_invoiced.sum(:effective_hours)
+  end
+
+  def percentage_complete
+    return 100 unless self.estimated_hours
+    begin
+      percent = (((self.hours / self.estimated_hours)).to_f * 100.00).round(2)
+      [percent, 100].min
+    rescue
+      0
+    end
+  end
+
+  def remaining_hours
+    if self.estimated_hours and self.estimated_hours > self.hours
+      self.estimated_hours - self.hours
+    else
+      0
+    end
+  end
+
+  def long_name
+    "Ticket: [#{id}] - #{project.name} - #{name} ticket for #{client.name}"
+  end
+
+  def allows_access?(user)
+    project.accepts_roles_by?(user) || user.admin?
+  end
+
+  def files_and_comments
+    [comments, file_attachments].flatten.sort_by {|x| x.created_at}
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,147 @@
+class User < ActiveRecord::Base
+  # Include default devise modules. Others available are:
+  # :token_authenticatable, :confirmable, :lockable and :timeoutable
+  devise :database_authenticatable, :rememberable, :trackable, :validatable, :lockable, :token_authenticatable
+
+  include Gravtastic
+  gravtastic
+  is_gravtastic!
+
+  acts_as_authorization_subject :association_name => :roles, :join_table_name => :roles_users
+  acts_as_tagger
+
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :email, :password, :password_confirmation, :remember_me,
+                  :first_name, :last_name, :middle_initial, :full_width,
+                  :daily_target_hours, :expanded_calendar, :client
+
+  validates_presence_of :first_name, :last_name
+  validates_length_of :middle_initial, :is => 1
+
+  has_many :work_units
+  has_many :comments
+
+  # Scopes
+  def self.with_unpaid_work_units
+    select('distinct users.*').joins(:work_units).where(:work_units => {:paid => [nil, '']})
+  end
+
+  scope :unlocked, where(:locked_at => nil)
+  scope :locked,   where('locked_at IS NOT NULL')
+  scope :sort_by_name, order('first_name ASC')
+  scope :developers, lambda { joins("INNER JOIN roles r on r.authorizable_type='Project'").joins("INNER JOIN roles_users ru ON ru.role_id = r.id").joins("INNER JOIN users u ON ru.user_id = u.id").where("r.name = 'developer'").where("ru.user_id = users.id") }
+  scope :for_project, lambda{|project|
+    joins("INNER JOIN roles r ON r.authorizable_type='Project' AND r.authorizable_id=#{project.id}").joins("INNER JOIN roles_users ru ON ru.role_id = r.id").joins("INNER JOIN users u ON ru.user_id = u.id").where("ru.user_id = users.id")
+  }
+
+  # Return the initials of the User
+  def initials
+    "#{first_name[0,1]}#{middle_initial}#{last_name[0,1]}".upcase
+  end
+
+  def work_units_between(start_time, end_time)
+    work_units.scheduled_between(start_time.beginning_of_day, end_time.end_of_day)
+  end
+
+  def work_units_for_day(time)
+    work_units.scheduled_between(time.beginning_of_day, time.end_of_day)
+  end
+
+  def clients_for_day(time)
+    work_units_for_day(time).map{|x| x.client}.uniq
+  end
+
+  def work_units_for_week(time)
+    work_units.scheduled_between(time.beginning_of_week, time.end_of_week)
+  end
+
+  def hours_entered_for_day(time)
+    hours = 0
+    work_units_for_day(time).each do |w|
+      hours += w.hours
+    end
+    hours
+  end
+  def unpaid_work_units
+    work_units.unpaid
+  end
+
+  def to_s
+    "#{first_name.capitalize} #{middle_initial.capitalize} #{last_name.capitalize}"
+  end
+
+  def client?
+    @client ||= has_role?(:client)
+  end
+
+  def developer?
+    @developer ||= has_role?(:developer)
+  end
+
+  def admin?
+    @admin ||= has_role?(:admin)
+  end
+
+  def locked
+    locked_at?
+  end
+
+  def pto_hours_left(date)
+    raise "Date must be a date object" unless date.is_a?(Date)
+    time = date.to_time_in_current_zone
+    SiteSettings.first.total_yearly_pto_per_user - work_units.pto.scheduled_between(time.beginning_of_year, time).sum(:hours)
+  end
+
+  # TODO: refactor this mess
+  def expected_hours(date)
+    raise "Date must be a date object" unless date.is_a?(Date)
+    # no expected hours if the user has never worked
+    return 0 unless work_units.present?
+    # set the user's first day by the first work unit
+    first_day = work_units.first.scheduled_at.to_date
+    # no expected hours if their first day is in the future
+    return 0 if first_day > date
+    if first_day.year == date.year
+      # if their first day was in the same year as the date
+      # calculate the offset of the first week, incase they dont start on monday
+      first_week_offset = first_day.cwday - 1
+      # caculate total days from previous week, subtracting the first week offset
+      days_from_prev_weeks = ((date.cweek - first_day.cweek) * 5) - first_week_offset
+      # get the number of work days in the targeted week that have passed
+      days_from_cur_week = [date.cwday, 5].min
+    else
+      # user has been here all year, count total work days in year
+      days_from_prev_weeks = (date.cweek - 1) * 5
+      days_from_cur_week = [date.cwday, 5].min
+    end
+    # calculate expected hours off of total expected days
+    (days_from_prev_weeks + days_from_cur_week) * daily_target_hours
+  end
+
+  def target_hours_offset(date)
+    raise "Date must be a date object" unless date.is_a?(Date)
+    worked_hours = WorkUnit.for_user(self).scheduled_between(date.beginning_of_year, date.end_of_day).sum(:hours)
+    worked_hours - expected_hours(date)
+  end
+
+  def entered_time_yesterday?
+    return true if !developer? || admin?
+    previous_work_days_work_units.any?
+  end
+
+  def previous_work_days_work_units
+    work_units_between(Date.current.prev_working_day.beginning_of_day, Date.current.prev_working_day.end_of_day)
+  end
+
+  def percentage_work_for(client, start_date, end_date)
+    raise "client must be a Client instance" unless client.is_a?(Client)
+    raise "Date must be a date object" unless start_date.is_a?(Date) && end_date.is_a?(Date)
+    # note: I'm returning an integer here, as I think that is specific enough for the
+    # reporting use case, this can easily be changed if future needs demand
+    wu = work_units.scheduled_between(start_date.beginning_of_day, end_date.end_of_day)
+    total_hours = wu.sum(:effective_hours)
+    client_hours = wu.for_client(client).sum(:effective_hours)
+    # Dividing by 0 is bad, mkay?
+    total_hours == 0 ? 0 : ((100 * client_hours)/total_hours).round
+  end
+end

data/app/models/weekly_time_report.rb

@@ -0,0 +1,26 @@
+# Get internal/external hour split for a given week
+class WeeklyTimeReport
+  def initialize(date_in_week=Time.zone.now, partial_week=false)
+    @date = date_in_week
+    @partial_week = partial_week
+  end
+
+  def run
+    get_weekly_hours(@date)
+  end
+
+  def sum_hours(method, hours)
+    hours.select{|wu| wu.send(method) }.sum(&:hours)
+  end
+
+  def get_weekly_hours(date)
+    start_date = date.beginning_of_week.to_date
+    if @partial_week
+      end_date = date
+    else
+      end_date = date.end_of_week.to_date
+    end
+    work_units = WorkUnit.scheduled_between(start_date, end_date)
+    { external: sum_hours(:external?, work_units).to_i, internal: sum_hours(:internal?, work_units).to_i }
+  end
+end

data/app/models/work_unit.rb

@@ -0,0 +1,99 @@
+class WorkUnit < ActiveRecord::Base
+  include GuidReferenced
+  extend WorkUnit::Finders
+  acts_as_commentable
+
+  has_many :comments, :as => :commentable
+  belongs_to :ticket
+  belongs_to :user
+
+  validates_presence_of :ticket_id, :user_id, :description, :hours, :scheduled_at, :effective_hours, :hours_type
+  validates_numericality_of :hours, :greater_than => -1
+  before_validation :set_effective_hours!
+  after_validation :validate_client_status
+  after_create :send_email!
+
+  def validate_client_status
+    if client && client.status == "Inactive"
+      self.errors.add(:base, "Cannot create work units on inactive clients.")
+    end
+  end
+
+  def internal?
+    SiteSettings.first.try(:client) == client
+  end
+
+  def external?
+    !internal?
+  end
+
+  def send_email!
+    WorkUnitNotifierWorker.perform_async(id, email_list) if email_list.any?
+  end
+
+  def email_list
+    Contact.for_client(self.client).receives_email.map(&:email_address)
+  end
+
+  def client
+    (ticket && ticket.client) ? ticket.project.client : nil
+  end
+
+  def project
+    ticket.project
+  end
+
+  def unpaid?
+    paid.blank?
+  end
+
+  def paid?
+    !unpaid?
+  end
+
+  def invoiced?
+    !not_invoiced?
+  end
+
+  def not_invoiced?
+    invoiced.blank?
+  end
+
+  def to_s
+    if new_record?
+      I18n.t(:new_work_unit)
+    else
+      description[0..80]
+    end
+  end
+
+  def allows_access?(user)
+    project.accepts_roles_by?(user) || user.has_role?(:admin)
+  end
+
+  def overtime_multiplier
+    if ticket && project && project.overtime_multiplier
+      project.overtime_multiplier
+    elsif client && client.overtime_multiplier
+      client.overtime_multiplier
+    elsif SiteSettings.first && SiteSettings.first.overtime_multiplier
+      SiteSettings.first.overtime_multiplier
+    else
+      BigDecimal.new("1.5")
+    end
+  end
+
+  def set_effective_hours!
+    if hours
+      if hours_type == "Overtime"
+        self.effective_hours = hours * overtime_multiplier
+      else
+        self.effective_hours = hours
+      end
+    end
+  end
+
+  def overtime?
+    hours_type == "Overtime"
+  end
+end