xrono 1.0.0

data/app/controllers/admin/weekly_time_report_controller.rb

@@ -0,0 +1,11 @@
+class Admin::WeeklyTimeReportController < Admin::BaseController
+  def index
+    redirect_to('/admin/weekly_time_report/' + Date.current.beginning_of_week.strftime("%F"))
+  end
+
+  def show
+    redirect_unless_monday('/admin/weekly_time_report/', params[:id])
+    @users = User.sort_by_name.select{|u| u.has_role?(:developer) && !u.locked }
+    @weekly_hours_sum = ChartData.external_hours_for_chart(@users, :date => @start_date)
+  end
+end

data/app/controllers/api/base_controller.rb

@@ -0,0 +1,14 @@
+class Api::BaseController < ApplicationController
+  skip_before_filter :authenticate_user!
+  skip_before_filter :verify_authenticity_token
+  before_filter :verify_api_login
+  respond_to :json
+
+  def verify_api_login
+    render :json => {:success => false} unless current_user && params[:auth_token]
+  end
+
+  def current_resource_owner
+    User.find(doorkeeper_token.resource_owner_id) if doorkeeper_token
+  end
+end

data/app/controllers/api/v1/base_controller.rb

@@ -0,0 +1,2 @@
+class Api::V1::BaseController < Api::BaseController
+end

data/app/controllers/api/v1/clients_controller.rb

@@ -0,0 +1,10 @@
+class Api::V1::ClientsController < Api::V1::BaseController
+  def index
+    @clients = Client.order("name")
+    unless admin?
+      @clients = @clients.for_user(current_user)
+    end
+    @clients = @clients.where(:initials => params[:initials]) unless params[:initials].blank?
+    render :json => @clients
+  end
+end

data/app/controllers/api/v1/credentials_controller.rb

@@ -0,0 +1,10 @@
+class Api::V1::CredentialsController < Api::V1::BaseController
+  skip_before_filter :verify_api_login
+  doorkeeper_for :all
+
+  respond_to :json
+
+  def me
+    respond_with current_resource_owner
+  end
+end

data/app/controllers/api/v1/projects_controller.rb

@@ -0,0 +1,27 @@
+class Api::V1::ProjectsController < Api::V1::BaseController
+  before_filter :load_client_from_client_initials, :only => [:index]
+
+  def index
+    @bucket = Project.sort_by_name
+    @bucket = @bucket.for_client_id(params[:client_id]) unless params[:client_id].blank?
+    @bucket = @bucket.where(:git_repo_url => params[:git_repo_url]) unless params[:git_repo_url].blank?
+    unless admin?
+      @bucket = @bucket.for_user(current_user)
+    end
+    render :json => @bucket.all
+  end
+
+  def create
+    @project = Project.new(params[:project])
+    if @project.save
+      render :json => {:success => true, :id => @project.id} and return
+    else
+      render :json => {:success => false, :errors => @project.errors.full_messages.to_sentence} and return
+    end
+  end
+
+  private
+  def load_client_from_client_initials
+    params[:client_id] = Client.where(:initials => params[:client_initials]).first.id unless params[:client_initials].blank?
+  end
+end

data/app/controllers/api/v1/tickets_controller.rb

@@ -0,0 +1,46 @@
+class Api::V1::TicketsController < Api::V1::BaseController
+  def index
+    @bucket = Ticket.order("name")
+
+    @bucket = @bucket.where(:project_id => params[:project_id]) unless params[:project_id].blank?
+    @bucket = @bucket.for_repo_url_and_branch(params[:repo_url],params[:branch]) unless params[:repo_url].blank? && params[:branch].blank?
+
+    json_array = []
+    @bucket.all.each do |ticket|
+      json_array << build_hash_for_ticket(ticket)
+    end
+    render :json => json_array
+  end
+
+  def show
+    @ticket = Ticket.find params[:id]
+
+    json_hash = {
+        :name                 => @ticket.name,
+        :estimated_hours      => @ticket.estimated_hours,
+        :percentage_complete  => @ticket.percentage_complete,
+        :hours                => @ticket.hours
+    }
+    render :json => json_hash
+  end
+
+  def create
+    @ticket = Ticket.new(params[:ticket])
+    if @ticket.save
+      render :json => {:success => true} and return
+    else
+      render :json => {:success => false, :errors => @ticket.errors.full_messages.to_sentence} and return
+    end
+  end
+
+  private
+  def build_hash_for_ticket ticket
+      {
+          :id                   => ticket.id,
+          :name                 => ticket.name,
+          :estimated_hours      => ticket.estimated_hours,
+          :percentage_complete  => ticket.percentage_complete,
+          :hours                => ticket.hours
+      }
+  end
+end

data/app/controllers/api/v1/tokens_controller.rb

@@ -0,0 +1,30 @@
+class Api::V1::TokensController < Api::V1::BaseController
+  skip_before_filter :verify_api_login
+
+  def create
+    @user = User.find_by_email(params["email"])
+
+    if @user.nil?
+      render :json => {:success => false} and return
+    end
+
+    @user.ensure_authentication_token!
+
+    if @user.valid_password?(params["password"])
+      json_hash = {
+        :token              => @user.authentication_token,
+        :success            => true,
+        :admin              => @user.admin?,
+        :current_hours      => @user.unpaid_work_units.sum(:effective_hours),
+        :pto_hours          => @user.pto_hours_left(Date.today.end_of_week),
+        :offset             => @user.target_hours_offset(Date.today),
+        :client             => @user.client?
+      }
+
+      json_hash[:client_id] = Client.for_user(@user).first.try(:id) if @user.client
+      render :json => json_hash and return
+    else
+      render :json => {:success => false} and return
+    end
+  end
+end

data/app/controllers/api/v1/work_units_controller.rb

@@ -0,0 +1,23 @@
+class Api::V1::WorkUnitsController < Api::V1::BaseController
+  def index
+    get_calendar_details
+    bucket = WorkUnit.scheduled_between(@start_date, @start_date + 6.days)
+    if params[:external_only]
+      client = SiteSettings.first.try(:client)
+      bucket = bucket.except_client(client)
+    end
+    @work_units = bucket.all
+    render :json => @work_units
+  end
+
+  def create
+    @work_unit = WorkUnit.new(params[:work_unit])
+    @work_unit.user = current_user
+    if @work_unit.save
+      render :json => {:success => true} and return
+    else
+      Rails.logger.warn @work_unit.errors.full_messages.to_sentence
+      render :json => {:succes => false, :errors => @work_unit.errors.full_messages.to_sentence} and return
+    end
+  end
+end

data/app/controllers/client_login/base_controller.rb

@@ -0,0 +1,3 @@
+class ClientLogin::BaseController < ApplicationController
+  skip_before_filter :redirect_clients
+end

data/app/controllers/client_login/clients_controller.rb

@@ -0,0 +1,35 @@
+class ClientLogin::ClientsController < ClientLogin::BaseController
+  before_filter :load_client, :only => [:show]
+
+  access_control do
+    allow :admin
+
+    action :index do
+      allow :client
+    end
+
+    action :show do
+      allow :client, :if => :user_is_authorized
+    end
+  end
+
+public
+  def index
+    @clients = Client.order('name').for_user(current_user)
+    redirect_to client_login_client_path(@clients.first) if @clients.count == 1
+  end
+
+  def show
+    bucket = Project.sort_by_name.for_client(@client).for_user(current_user)
+    @projects = bucket.all
+  end
+
+private
+  def user_is_authorized
+    @client.allows_access? current_user
+  end
+
+  def load_client
+    @client = Client.find(params[:id])
+  end
+end

data/app/controllers/client_login/contacts_controller.rb

@@ -0,0 +1,53 @@
+class ClientLogin::ContactsController < ClientLogin::BaseController
+  include ControllerMixins::Contacts
+
+  before_filter :load_client
+  before_filter :load_contact, :only => [:show, :edit, :update, :destroy]
+
+  access_control do
+    allow :client, :to => [:new, :create, :edit, :update, :show, :index], :if => :client_is_current_client?
+  end
+
+protected
+  def load_client
+    @client = Client.find(params[:client_id])
+  end
+
+  def load_contact
+    @contact = Contact.find(params[:id])
+  end
+
+
+public
+  def index
+    @contacts = @client.contacts.all
+  end
+
+  def show
+  end
+
+  def new
+    @contact = Contact.new(params[:contact])
+  end
+
+  def create
+    create!(:client_login_client_contact_path)
+  end
+
+  def update
+    update!(:client_login_client_contact_path)
+  end
+
+  def edit
+  end
+
+  def destroy
+    destroy!(:client_login_client_contacts_path)
+  end
+
+private
+  def client_is_current_client?
+    Client.for_user(current_user).include?(@client)
+  end
+
+end

data/app/controllers/client_login/projects_controller.rb

@@ -0,0 +1,24 @@
+class ClientLogin::ProjectsController < ClientLogin::BaseController
+  include ControllerMixins::Authorization
+
+  before_filter :load_project, :only => [:show]
+  before_filter :load_file_attachments, :only => [:show]
+
+  authorize_owners_with_client_show(:project)
+
+  # GET /projects/:id
+  def show
+    @tickets = Ticket.for_project(@project).sort_by_name
+    # FIXME - not showing correct group of work_units
+    @work_units = Project.find(params[:id]).work_units
+  end
+
+  private
+  def load_project
+    @project = Project.find(params[:id])
+  end
+
+  def load_file_attachments
+    @file_attachments = @project.file_attachments
+  end
+end

data/app/controllers/client_login/reports_controller.rb

@@ -0,0 +1,23 @@
+class ClientLogin::ReportsController < ClientLogin::BaseController
+  before_filter :load_projects, :only => [:work_units]
+  def index
+  end
+
+  def work_units
+    params[:start_date_hidden] ||= Date.current.beginning_of_month.to_s
+    params[:end_date_hidden] ||= Date.current.end_of_month.to_s
+    start_date = Time.zone.parse(params[:start_date_hidden]).beginning_of_day
+    end_date = Time.zone.parse(params[:end_date_hidden]).end_of_day
+    if params[:project_id].nil?
+      project = Project.for_user(current_user).first
+    else
+      project = Project.for_user(current_user).find params[:project_id]
+    end
+    @work_units = WorkUnit.order("scheduled_at desc").for_project(project).scheduled_between(start_date,end_date)
+  end
+
+  private
+  def load_projects
+    @projects = Project.for_user(current_user)
+  end
+end

data/app/controllers/client_login/tickets_controller.rb

@@ -0,0 +1,41 @@
+class ClientLogin::TicketsController < ClientLogin::BaseController
+  include ControllerMixins::Tickets
+
+  before_filter :load_new_ticket, :only => [:new, :create]
+  before_filter :load_ticket, :only => [:show, :edit, :update, :advance_state, :reverse_state, :ticket_detail]
+  before_filter :load_project
+
+  access_control do
+    allow :admin
+    allow :developer, :of => :project
+    allow :client, :of => :project, :to => [:show, :new, :create]
+  end
+
+  # GET /tickets/new
+  def new
+  end
+
+  # POST /tickets
+  def create
+    @ticket.estimated_hours = 0.0
+    create!(:client_login_ticket_path) # In ControllerMixins::Tickets module
+  end
+
+  # GET /tickets/:id
+  def show
+    @work_units = WorkUnit.for_ticket(@ticket).sort_by_scheduled_at
+    unless @ticket.estimated_hours
+      flash.now[:notice] = "NOTE: The estimated amount of time to complete this ticket has not been entered."
+    end
+
+    if @ticket.percentage_complete.to_i > 100
+      flash.now[:notice] = "WARNING: Ticket has exceeded the estimated amount of time to be completed."
+    end
+  end
+
+  private
+  # Acl9's access control block looks for @project in order to use "allow <role> :of => :project"
+  def load_project
+    @project = @ticket.project
+  end
+end

data/app/controllers/client_login/work_units_controller.rb

@@ -0,0 +1,11 @@
+class ClientLogin::WorkUnitsController < ClientLogin::BaseController
+  include ControllerMixins::WorkUnits
+  include ControllerMixins::Authorization
+
+  authorize_owners_with_client_show(:project)
+
+  # GET /work_units/:id
+  def show
+    @work_unit = WorkUnit.find params[:id]
+  end
+end

data/app/controllers/clients_controller.rb

@@ -0,0 +1,103 @@
+class ClientsController < ApplicationController
+  include ControllerMixins::Generic
+
+  before_filter :load_new_client, :only => [:new, :create]
+  before_filter :load_client, :only => [:edit, :show, :update]
+  before_filter :load_file_attachments, :only => [:show, :new, :create]
+
+  access_control do
+    allow :admin
+
+    action :index do
+      allow :developer
+      allow :client
+    end
+
+    action :inactive_clients do
+      allow :developer
+    end
+
+    action :suspended_clients do
+      allow :developer
+    end
+
+    action :show_complete do
+      allow :developer
+      allow :client
+    end
+
+    action :show do
+      allow :developer, :if => :user_is_authorized
+      allow :client, :if => :user_is_authorized
+    end
+  end
+
+  protected
+  def load_new_client
+    @client = Client.new(params[:client])
+  end
+
+  def load_client
+    @client = Client.find(params[:id])
+  end
+
+  def load_file_attachments
+    @file_attachments = @client.file_attachments
+  end
+
+  public
+  def index
+    @clients = authorized_clients.active
+  end
+
+  def inactive_clients
+    @clients = authorized_clients.inactive
+  end
+
+  def suspended_clients
+    @clients = authorized_clients.suspended
+  end
+
+  def show
+    @bucket = Project.order("name").for_client(@client)
+    @bucket = @bucket.for_user(current_user) unless admin?
+
+    @work_units = WorkUnit.for_client(@client).order("work_units.created_at DESC").limit(100)
+
+    @incompleted_projects = @bucket.incomplete
+    @completed_projects = @bucket.complete
+  end
+
+  def new
+  end
+
+  def create
+    generic_save_and_redirect(:client, :create)
+  end
+
+  def update
+    if @client.update_attributes(params[:client])
+      flash[:notice] = t(:client_updated_successfully)
+      redirect_to client_path(@client)
+    else
+      flash.now[:error] = t(:client_updated_unsuccessfully)
+      render :edit
+    end
+  end
+
+  def edit
+  end
+
+  private
+  def user_is_authorized
+    @client.allows_access? current_user
+  end
+
+  def authorized_clients
+    if admin?
+      Client.order("name")
+    else
+      Client.order("name").for_user(current_user)
+    end
+  end
+end