xrono 1.0.0

data/app/controllers/work_units_controller.rb

@@ -0,0 +1,114 @@
+class WorkUnitsController < ApplicationController
+  include ControllerMixins::WorkUnits
+  include ControllerMixins::Authorization
+
+  before_filter :create_ticket, :only => [:create_in_dashboard]
+  before_filter :load_new_work_unit, :only => [:new, :create_in_dashboard]
+  before_filter :check_for_params, :only => [:create_in_dashboard]
+  before_filter :load_work_unit, :only => [:show, :edit, :update]
+  before_filter :require_admin, :only => [:index]
+
+  authorize_owners_with_client_show(:project)
+
+  def new
+  end
+
+  def create_in_dashboard
+    if request.xhr?
+      if @work_unit.save
+        suspended = @work_unit.client.status == "Suspended"
+        if suspended
+          render :json   => {success: true, notice: "This client is suspended. Please contact an Administrator."},
+                 :layout => false,
+                 :status => 200 and return
+        else
+          render :json   => {success: true}, :layout => false, :status => 200 and return
+        end
+      else
+        render :json => @work_unit.errors.full_messages.to_json, :layout => false, :status => 406 and return
+        flash[:error] = t(:work_unit_created_unsuccessfully)
+      end
+    end
+  end
+
+  def create_in_ticket
+    @work_unit = WorkUnit.new(params[:work_unit])
+    @work_unit.user = current_user
+    if @work_unit.save
+      flash[:notice] = "Work Unit created successfully"
+      redirect_to ticket_path(@work_unit.ticket)
+    else
+      flash[:error] = "There was a problem creating the work unit."
+      render 'work_units/new'
+    end
+  end
+
+  def show
+  end
+
+  def edit
+  end
+
+  def update
+    if @work_unit.update_attributes(params[:work_unit])
+      flash[:notice] = t(:work_unit_updated_successfully)
+      redirect_to @work_unit
+    else
+      flash.now[:error] = t(:work_unit_updated_unsuccessfully)
+      redirect_to edit_work_unit_path
+    end
+  end
+
+  private
+  def check_internal_client
+    params[:work_unit][:client_id].to_i == @site_settings.client_id
+  end
+
+  def check_for_params
+    [:client_id, :project_id, :hours, :description].each do |key|
+      if params[:work_unit][key].blank?
+        render :json => {:success => false, :errors => "#{key.to_s.gsub("_id","")} can't be blank." }, :layout => false, :status => 406 and return
+      end
+    end
+    if params[:hours_type].blank?
+      render :json => {:success => false, :errors => "You must select an hours type." }, :layout => false, :status => 406 and return
+    elsif params[:hours_type] == "CTO" && !check_internal_client
+      render :json => {:success => false, :errors => "You can only select CTO as hours type on internal client." }, :layout => false, :status => 406 and return
+    end
+  end
+
+  def load_new_work_unit
+    _params = (params[:work_unit] || {}).dup
+    _params.delete :client_id
+    _params.delete :project_id
+    # ticket_id is sent as a child of work unit from the dashboard page, but not from the new work unit page.
+    # consequently, we'll find it wherever it may be
+    ticket_id = params[:ticket_id] || _params[:ticket_id]
+    @ticket    = Ticket.find_by_id ticket_id
+    @work_unit = WorkUnit.new(_params)
+    @work_unit.user = current_user
+    @work_unit.ticket = @ticket
+    @work_unit.scheduled_at ||= Date.today
+    #if _params[:scheduled_at].present?
+    #  @work_unit.scheduled_at = Time.zone.parse(_params[:scheduled_at])
+    #end
+    @work_unit.hours_type = params[:hours_type]
+  end
+
+  def load_work_unit
+    @work_unit = WorkUnit.find(params[:id])
+  end
+
+  def create_ticket
+    if params["ticket"]
+      @ticket = Ticket.new(params["ticket"])
+      @ticket.project_id = params[:work_unit][:project_id]
+      if @ticket.save
+        params.delete :ticket
+        params[:work_unit][:ticket_id] = @ticket.id
+      else
+        render :json => {:success => false, :errors => "On Demand Ticket was invalid"}, :layout => false, :status => 406 and return
+      end
+    end
+  end
+end

data/app/controllers/xrono/application_controller.rb

@@ -0,0 +1,65 @@
+class Xrono::ApplicationController < ActionController::Base
+  include RefurlHelper
+  helper Xrono.helpers
+  layout 'application'
+  protect_from_forgery
+
+  before_filter :initialize_site_settings
+  before_filter :redirect_clients
+  before_filter :authenticate_user!, :except => [:payload]
+  helper_method :redirect_to_ref_url, :admin?, :client?, :external_hours_for_chart
+  rescue_from 'Acl9::AccessDenied', :with => :access_denied
+
+  def get_calendar_details
+    if params[:date].present? && params[:date] != "null"
+      @start_date = Date.parse(params[:date]).beginning_of_week
+    else
+      @start_date = Date.current.beginning_of_week
+    end
+  end
+
+  private
+  def require_admin
+    unless admin?
+      flash[:error] = t(:you_must_be_an_admin_to_do_that)
+      redirect_to root_path
+    end
+  end
+
+  def admin?
+    current_user && current_user.admin?
+  end
+
+  def client?
+    current_user && current_user.client?
+  end
+
+  def access_denied
+    flash[:notice] = 'Access denied.'
+    if client?
+      redirect_to client_login_clients_path
+    else
+      redirect_to root_path
+    end
+  end
+
+  def initialize_site_settings
+    @site_settings = SiteSettings.first || SiteSettings.create(site_settings_defaults)
+  end
+
+  def redirect_clients
+    return if params[:controller] == "devise/sessions"
+    if client?
+      redirect_to client_login_clients_path unless admin?
+    end
+  end
+
+  def get_tag_list_for(array)
+    array.join(",")
+  end
+
+  protected
+  def site_settings_defaults
+    { :total_yearly_pto_per_user => BigDecimal('40'), :overtime_multiplier => BigDecimal('1.5') }
+  end
+end

data/app/helpers/admin/unentered_time_report_helper.rb

@@ -0,0 +1,9 @@
+module Admin::UnenteredTimeReportHelper
+  def hours_entered_for_day time
+    hours = 0
+    @users.each do |u|
+      hours += u.hours_entered_for_day(time)
+    end
+    hours
+  end
+end

data/app/helpers/admin_base_helper.rb

@@ -0,0 +1,14 @@
+module AdminBaseHelper
+  # This method returns a string for the table row class based on a work unit's
+  # hours type. It uses cycle to candy-stripe the table for readability.
+  def row_class(options={})
+    classes = []
+    classes.push(options[:hours_type].downcase) if options[:hours_type]
+
+    classes.push("future") if options[:scheduled_at] > Time.current
+
+    classes = classes.join(' ')
+
+    cycle("#{classes} even","#{classes} odd")
+  end
+end

data/app/helpers/clients_helper.rb

@@ -0,0 +1,5 @@
+module ClientsHelper
+  def client_status_select(selected=nil)
+    options_for_select(Client.statuses.values, selected)
+  end
+end

data/app/helpers/dashboard_helper.rb

@@ -0,0 +1,9 @@
+module DashboardHelper
+  def render_message(message)
+    if message
+      content_tag('div', :id => 'message', :title => message[:title], :style => 'display: none;') do
+        content_tag('p', message[:body])
+      end
+    end
+  end
+end

data/app/helpers/gravatar_helper.rb

@@ -0,0 +1,5 @@
+module GravatarHelper
+  def show_gravatar_for(user, size=80)
+    image_tag(user.gravatar_url(:size => size)) if user
+  end
+end

data/app/helpers/refurl_helper.rb

@@ -0,0 +1,9 @@
+module RefurlHelper
+  def redirect_to_ref_url
+    if params[:refurl]
+      redirect_to params[:refurl]
+    else
+      redirect_to root_path
+    end
+  end
+end

data/app/helpers/xrono/application_helper.rb

@@ -0,0 +1,54 @@
+require 'acl9'
+module Xrono::ApplicationHelper
+  include ::Acl9::Helpers
+
+  def bootstrap_icon(name)
+    content_tag('i', nil, :class => "icon-#{name}")
+  end
+
+  def external_work_percentage(user, start_date, end_date)
+    if @site_settings.client
+      internal = user.percentage_work_for(@site_settings.client, start_date, end_date)
+      (100 - internal).to_s
+    end
+  end
+
+  def last_effective_date(start_date)
+    if start_date.end_of_week > Date.current
+      Date.current
+    else
+      start_date.end_of_week
+    end
+  end
+
+  def render_label_for(hour_type)
+    label_type = label_type_for(hour_type)
+    if label_type
+      haml_tag(:div, :class => 'label ' << label_type) do
+        haml_concat hour_type
+      end
+    end
+  end
+
+  def label_type_for(hour_type)
+    {
+      'Overtime' => 'important',
+      'PTO'      => 'success',
+      'CTO'      => 'warning'
+    }[hour_type]
+  end
+
+  def project_completion_metric(project)
+    work_unit_hours_array = Array.new # Empty array to work with
+
+    # Take the summation of estimated_hours on a ticket from the project
+    estimated_hours = Ticket.for_project(project).sum(:estimated_hours)
+    
+    # Push the work unit hours in if the ticket on the project has estimated hours
+    work_unit_hours = WorkUnit.for_project(project).on_estimated_ticket.sum(:hours)
+    
+    # Calculatre the projects completion as a percent
+    percent = (((work_unit_hours / estimated_hours)).to_f * 100.00).to_i rescue 0
+    [percent, 100].min # Make sure you don't go over 100 percent and confuse the graphs
+  end
+end

data/app/mailers/notifier.rb

@@ -0,0 +1,18 @@
+class Notifier < ActionMailer::Base
+  default :from => "no-reply@xrono.org"
+
+  def daily(client_id)
+    @client = Client.find(client_id)
+    @hours = WorkUnit.for_client(@client).sum(:hours)
+    @uninvoiced_hours = WorkUnit.for_client(@client).not_invoiced.sum(:hours)
+    mail(:to => Contact.for_client(@client).receives_email.map(&:email_address),
+         :bcc => ["bcc@xrono.org"],
+         :subject => 'Daily Hours Summary') {|f| f.text}
+  end
+
+  def work_unit_notification(work_unit_id, addresses)
+    addresses += %w(laird@isotope11.com josh@isotope11.com)
+    @work_unit = WorkUnit.find work_unit_id
+    mail(:bcc => addresses, :subject => "[Xrono] Work Unit: #{@work_unit.guid}") {|f| f.text}
+  end
+end

data/app/models/chart_data.rb

@@ -0,0 +1,20 @@
+module ChartData
+  def self.external_hours_for_chart(users, options = {})
+    users                 = Array(users)
+    date                  = options.fetch(:date, Time.zone.now)
+    start_date, end_date  = date.beginning_of_week.to_date, date.end_of_week.to_date
+
+    final_array = []
+    (start_date..end_date).each do |i_date|
+      _beg, _end = i_date.beginning_of_day, i_date.end_of_day
+      hours = WorkUnit.for_users(users).scheduled_between(_beg,_end).all
+      final_array << [i_date.strftime("%a"), sum_hours(:external?, hours).to_f, sum_hours(:internal?, hours).to_f]
+    end
+    final_array
+  end
+
+  protected
+  def self.sum_hours(method, hours)
+    hours.select{|wu| wu.send(method) }.sum(&:hours)
+  end
+end

data/app/models/client.rb

@@ -0,0 +1,98 @@
+class Client < ActiveRecord::Base
+  include GuidReferenced
+  acts_as_commentable
+  has_many :projects
+  has_many :tickets, :through => :projects
+  has_many :comments, :as => :commentable
+  has_many :file_attachments
+  has_many :contacts
+  has_one  :site_settings
+  has_one :data_vault, :as => :data_vaultable
+
+  validates_presence_of   :name, :status
+  validates_uniqueness_of :name, :allow_nil => false
+
+  after_create :create_data_vault
+
+  scope :sort_by_name, order('name ASC')
+  scope :active, where(:status => '10')
+  scope :suspended, where(:status => '20')
+  scope :inactive, where(:status => '30')
+  scope :for_user, lambda{|user|
+   joins("INNER JOIN projects p ON p.client_id=clients.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).select("distinct clients.*")
+  }
+
+  class << self
+    def statuses
+      {
+        "10" => "Active",
+        "20" => "Suspended",
+        "30" => "Inactive",
+      }
+    end
+
+    def for(projects_or_tickets_or_work_units)
+      projects_or_tickets_or_work_units.collect{ |resource| resource.client }.uniq
+    end
+  end
+
+  def recent_users
+    work_units.scheduled_between(2.weeks.ago, Time.zone.now).select("distinct user_id").includes(:user).map(&:user)
+  end
+
+  def tickets
+    Ticket.for_client(self)
+  end
+
+  def work_units
+    WorkUnit.for_client(self)
+  end
+
+  def hours
+    work_units.sum(:effective_hours)
+  end
+
+  def uninvoiced_hours
+    WorkUnit.for_client(self).not_invoiced.sum(:effective_hours)
+  end
+
+  def hours_this_month
+    WorkUnit.for_client(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_client(self).scheduled_between(Time.zone.now.beginning_of_week, Time.zone.now.end_of_week).sum(:effective_hours)
+  end
+
+  def to_s
+    if status == "Active"
+      name
+    else
+      "#{name} (#{status})"
+    end
+  end
+
+  def status
+    Client.statuses[attributes["status"]]
+  end
+
+  def status=(val)
+    write_attribute(:status, Client.statuses.invert[val])
+  end
+
+  def allows_access?(user)
+    projects.any? {|p| p.accepts_roles_by?(user)} || user.admin?
+  end
+
+  def files_and_comments
+    ary = Array.new
+    ary << comments
+    ary << file_attachments
+    ary.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/comment.rb

@@ -0,0 +1,8 @@
+class Comment < ActiveRecord::Base
+  include ActsAsCommentable::Comment
+
+  belongs_to :commentable, :polymorphic => true
+  belongs_to :user
+
+  default_scope :order => 'created_at DESC'
+end