backlog 0.37.2 → 0.41.4

data/app/controllers/projects_controller.rb

@@ -1,185 +0,0 @@
-class ProjectsController < ApplicationController
-  skip_before_filter :populate_layout, :only => [:index, :burn_down_chart, :burn_down_chart_thumbnail, :destroy]
-  
-  # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
-  verify :method => :post, :only => [ :destroy, :create, :update ], :redirect_to => { :action => :index }
-  
-  def index
-    flash.keep
-    if Task.find_started.size > 0
-      redirect_to :controller => 'tasks', :action => :list_started
-      return
-    end
-    if Project.count == 0
-      redirect_to :action => :new
-      return
-    end
-    most_urgent_project = Project.find(:first, :order => :id)
-    redirect_to :action => :show, :id => most_urgent_project.id
-  end
-  
-  def list
-    @projects = Project.find(:all, :order => 'name')
-  end
-  
-  def show
-    if params[:id]
-      @project = Project.find(params[:id])
-    end
-    unless @project
-      @project = Project.find(:first)
-      unless @project
-        redirect_to :controller => 'projects', :action => :new
-        return
-      end
-    end
-    load_tasks(@project)
-  end
-  
-  def show_no_layout
-    show
-    render :partial => 'tasks'
-  end
-  
-  def new
-    @project = Project.new
-  end
-  
-  def create
-    @project = Project.new(params[:project])
-    if @project.save
-      flash[:notice] = 'Project was successfully created.'
-      redirect_to :action => :show, :id => @project
-    else
-      render :action => 'new'
-    end
-  end
-  
-  def edit
-    @project = Project.find(params[:id])
-  end
-  
-  def edit_no_layout
-    edit
-    render :partial => 'tasks'
-  end
-  
-  def update
-    @project = Project.find(params[:id])
-    if @project.update_attributes(params[:project])
-      flash[:notice] = 'Project was successfully updated.'
-      back_or_redirect_to :action => :show, :id => @project
-    else
-      render :action => 'edit'
-    end
-  end
-  
-  def destroy
-    project = Project.find(params[:id])
-    project.work_lock_subscribers.delete_all
-    project.destroy
-    flash[:notice] = 'Project was successfully deleted.'
-    redirect_to :action => 'index'
-  end
-  
-  def update_task_estimate
-    if params[:id]
-      @task = Task.find_by_id(params[:id])
-      if params[:estimate] && params[:estimate][:todo]
-        begin
-          Float(params[:estimate][:todo])
-          @task.estimate(params[:estimate][:todo])
-          @period = @task.period
-          @success, flash[:notice] = true, 'Estimate updated'
-        rescue ArgumentError => e
-          @success, flash[:notice] = false, "Estimate was not numeric"
-        end
-        if @task.finished?
-          load_tasks(@task.project)
-          render :action => 'finish_task', :layout => false
-        else
-          render :template => '/tasks/update_estimate', :layout => false
-        end
-      else
-        return false, "Estimate is missing."
-      end
-    else
-      @estimate = Estimate.new
-      return false, 'Task id is missing.'
-    end
-  end
-  
-  def finish_task
-    @task = Task.find(params[:id])
-    @task.finish(Task::COMPLETED, true)
-    load_tasks(@task.project)
-  end
-  
-  def abort_task
-    @task = Task.find params[:id]
-    @task.abort
-    load_tasks(@task.project)
-    render :action => :finish_task, :layout => false
-  end
-  
-  def move_task_to_period
-    params[:id] = $1 if params[:id] =~ /^task_(\d*)/
-    @task = Task.find(params[:id])
-    if request.post?
-      period = params[:period_id] && Period.find(params[:period_id])
-      if period && period.active_or_future?
-        next_task = @task.higher_item ? @task.higher_item : @task.lower_item ? @task.lower_item : @task
-        @task.move_to_period period
-        load_tasks(@task.project)
-        render :action => :move_task_to_period, :layout => false
-      else
-        rjs_detour_to :controller => 'periods', :action => :new, :period => {:party_id => @task.period.party_id}, :layout => false
-      end
-    else
-      redirect_to :controller => 'periods', :action => :show, :id => @task.period, :task_id => @task.id, :layout => false
-    end
-  end
-  
-  def move_task_to_next_period
-    @task = Task.find(params[:id])
-    if @task.period
-      next_period = @task.period.lower_item
-      next_period = next_period.lower_item while next_period && next_period.passed?
-      params[:period_id] = next_period && next_period.id
-      move_task_to_period
-    else
-      rjs_redirect_to :controller => 'tasks', :action => :edit, :id => @task
-    end
-  end
-  
-  def reopen_task
-    @task = Task.find(params[:id]).reopen
-    load_tasks(@task.project)
-  end
-  
-  def order
-    params.keys.find {|k| k =~ /active_tasks_(.*)/}
-    period_id = $1
-    if period_id
-      period = period_id.empty? ? nil : Period.find(period_id)
-      tasks = params["active_tasks_#{period_id}"].select {|id| not id.empty?}
-      tasks.each_with_index do |id,idx|
-        task = Task.find(id)
-        task = task.move_to_period(period) if task.period != period
-        task.insert_at(idx + 1)
-        task.save!
-      end
-    end
-    render :text => 'alert("Updated sort order");'
-  end
-  
-  private
-  
-  def load_tasks(project)
-    unplanned_tasks = project.tasks.select {|t| t.period.nil? && t.finished_at.nil?}.sort_by {|t| t.position}
-    planned_tasks = project.tasks.select {|t| t.period && t.finished_at.nil?}.sort_by {|t| [t.period.end_on, t.position.to_i]}
-    @tasks = planned_tasks + unplanned_tasks
-    @completed_tasks = project.tasks.select {|t| t.finished_at}.sort {|t1, t2| t2.finished_at <=> t1.finished_at}
-  end
-  
-end

data/app/controllers/public_holidays_controller.rb

@@ -1,70 +0,0 @@
-class PublicHolidaysController < ApplicationController
-  def index
-    list
-    render :action => 'list'
-  end
-  
-  # GETs should be safe (see http://www.w3.org/2001/tag/doc/whenToUseGet.html)
-  verify :method => :post, :only => [ :destroy, :create, :update ],
-  :redirect_to => { :action => :list }
-  
-  def list
-    @public_holidays = PublicHoliday.paginate :per_page => 10, :page => params[:page]
-  end
-  
-  def show
-    @public_holiday = PublicHoliday.find(params[:id])
-  end
-  
-  def new
-    @public_holiday = PublicHoliday.new
-  end
-  
-  def create
-    @public_holiday = PublicHoliday.new(params[:public_holiday])
-    if @public_holiday.save
-      flash[:notice] = 'PublicHoliday was successfully created.'
-      redirect_to :action => 'list'
-    else
-      render :action => 'new'
-    end
-  end
-  
-  def edit
-    @public_holiday = PublicHoliday.find(params[:id])
-  end
-  
-  def update
-    @public_holiday = PublicHoliday.find(params[:id])
-    if @public_holiday.update_attributes(params[:public_holiday])
-      flash[:notice] = 'PublicHoliday was successfully updated.'
-      redirect_to :action => 'show', :id => @public_holiday
-    else
-      render :action => 'edit'
-    end
-  end
-  
-  def destroy
-    PublicHoliday.find(params[:id]).destroy
-    redirect_to :action => 'list'
-  end
-  
-  def mark
-    if params[:public_holiday]
-      on = params[:public_holiday][:on]
-      marked = params[:public_holiday][:marked] == '1'
-      @public_holiday = PublicHoliday.find(:first, :conditions => {:on => on})
-      if marked
-        if @public_holiday.nil?
-          PublicHoliday.create!(:on => on)
-        end
-      else
-        if @public_holiday
-          @public_holiday.destroy
-        end
-      end
-    end
-    back_or_redirect_to :controller => 'works', :action => :daily_work_sheet
-  end
-  
-end

data/app/controllers/search_controller.rb

@@ -1,15 +0,0 @@
-class SearchController < ApplicationController
-  
-  def results
-    if params[:q]
-      @search = params[:q]
-      @projects = Project.find(:all, :conditions => ["lower(name) LIKE ?", "%#{@search.downcase}%"])
-      @tasks = Task.find(:all, :conditions => ["lower(description) LIKE ? OR lower(notes) LIKE ?", "%#{@search.downcase}%", "%#{@search.downcase}%"])
-      @works = Work.find(:all, :conditions => ["lower(description) LIKE ? OR lower(notes) LIKE ?", "%#{@search.downcase}%", "%#{@search.downcase}%"])
-    else
-      @projects = []
-      @tasks = []
-      @works = []
-    end
-  end
-end

data/app/controllers/task_files_controller.rb

@@ -1,19 +0,0 @@
-class TaskFilesController < ApplicationController
-  def show
-    @task_file = TaskFile.find(params[:id])
-    send_data(@task_file.content_data,
-        :disposition => @task_file.image? ? 'inline' : 'attachment',
-        :type => @task_file.content_type,
-        :filename => @task_file.name)
-  end
-  
-  def destroy
-    @task_file = TaskFile.find(params[:id])
-    @task_file.destroy
-    
-    respond_to do |format|
-      format.html { redirect_to(:controller => 'tasks', :action => :edit, :id => @task_file.task) }
-      format.xml  { head :ok }
-    end
-  end
-end

data/app/controllers/tasks_controller.rb

@@ -1,305 +0,0 @@
-class TasksController < ApplicationController
-  skip_before_filter :populate_layout, :except => [:edit, :grab, :list_started, :move_down, :move_to_bottom, :move_to_top, :move_up, :new, :specify]
-  
-  verify :method => :post, :except => [ :invite, :new, :show, :edit, :grab, :list_started, :move_to_next_period, :notes],
-                           :redirect_to => { :controller => 'projects' }
-  
-  def list_started
-    @tasks = Task.find_started
-    @selected_task = Task.find_by_id(params[:id])
-    back_or_redirect_to('/') if @tasks.empty?
-  end
-  
-  def new
-    redirect_to params if request.post?
-    params[:task].delete :file if params[:task]
-    @task = Task.new params[:task]
-    @task.project_id ||= @task.period && @task.period.most_frequent_project
-    @projects = Project.find(:all, :order => 'name')
-    @periods = Period.find_active_or_future
-    @customers = Customer.find(:all)
-  end
-  
-  def create
-    if params[:task] && params[:task][:period_id] && params[:task][:period_id][0..0] == 'G'
-      detour_to :controller => 'periods', :action => :new, :group_id => params[:task][:period_id][1..-1].to_i
-      return
-    end
-    
-    file = params[:task].delete(:file)
-    
-    @task = Task.new(params[:task])
-    if @task.save
-      flash[:notice] = 'Task was successfully created.'
-      if file && file.respond_to?(:read) && file.respond_to?(:content_type) && file.respond_to?(:original_filename)
-        @task.task_files.create! :name => file.original_filename, :content_data => file.read, :content_type => file.content_type
-      end
-      @task.move_to_top
-      @task.grab
-      if @task.period
-        back_or_redirect_to :controller => 'periods', :action => 'show', :id => @task.period, :task => @task.id
-      else
-        back_or_redirect_to :controller => 'projects', :action => :edit, :id => @task.project, :task => @task.id
-      end
-    else
-      populate_layout
-      @projects = Project.find(:all, :order => 'name')
-      @periods = Period.find_active_or_future
-      @customers = Customer.find(:all)
-      render :action => 'new'
-    end
-  end
-  
-  def edit
-    @task ||= Task.find(params[:id])
-    @task.project_id = params[:task][:project_id] if params[:task] && params[:task][:project_id]
-    @task.period_id = params[:task][:period_id] if params[:task] && params[:task][:period_id]
-    @periods = Period.find_active_or_future
-    @projects = Project.find(:all, :order => 'name')
-    @customers = Customer.find(:all)
-  end
-  
-  def update
-    redirect_to(:controller => 'projects', :action => :index) unless params[:id]
-    if params[:task] && params[:task][:description] == ''
-      destroy
-      return
-    end
-    @task = Task.find(params[:id])
-    unless @task.period.nil? || @task.period.active_or_future? || (params[:task] && params[:task][:period_id] && params[:task][:period_id].to_i > 0 && (period = Period.find_by_id(params[:task][:period_id])) && period.active?)
-      @task.errors.add(:period_id, "You may not update a task in an inactive period.  Move the task to an active period first.")
-      back_or_redirect_to :controller => 'periods', :action => :show, :id => @task.period, :task => @task.id
-      return
-    end
-    
-    # TODO (uwe): This should be moved to the Task model: Task#period=
-    if params[:task] && params[:task][:period_id]
-      if params[:task][:period_id] != ''
-        if params[:task][:period_id].to_i != @task.period_id
-          @task.remove_from_list
-          params[:task][:position] = Period.find(params[:task][:period_id]).tasks.size
-        end
-      else
-        if @task.period_id != nil
-          @task.remove_from_list
-          @task.period = nil
-          new_pos = @task.project.tasks.count(:conditions => 'period_id IS NULL AND parent_id IS NULL') + 1
-          params[:task].delete(:period_id)
-          params[:task][:position] = new_pos
-        end
-      end
-    end
-    
-    file = params[:task] && params[:task].delete(:file)
-
-    if params[:task] && @task.update_attributes(params[:task])
-      flash[:notice] = 'Task was successfully updated.'
-      if params[:estimate]
-        @task.estimates.create! params[:estimate]
-      end
-      if file && file.respond_to?(:read) && file.respond_to?(:content_type) && file.respond_to?(:original_filename)
-        @task.task_files.create! :name => file.original_filename, :content_data => file.read, :content_type => file.content_type
-      end
-      if params[:estimate] && params[:estimate][:todo] && params[:estimate][:todo].to_i == 0
-        unless @task.finished_at
-          next_task = @task.lower_item || @task.higher_item
-          @task.finish Task::COMPLETED, true
-          @task.save!
-          back_or_redirect_to :controller => 'periods', :action => :show, :id => @task.period, :task => next_task ? next_task.id : nil
-        else
-          back_or_redirect_to :controller => 'periods', :action => :show, :id => @task.period, :task => @task.id
-        end
-      else
-        if @task.finished_at
-          @task.reopen
-          flash[:notice] += 'Task was reopened.'
-          populate_layout
-          render :action => 'edit'
-        else
-          if @task.period
-            back_or_redirect_to :controller => 'periods', :action => :show, :id => @task.period, :task => @task.id
-          else
-            back_or_redirect_to :controller => 'projects', :action => :show, :id => @task.project, :task => @task.id
-          end
-        end
-      end
-    else
-      flash[:notice] = 'Task was not saved.'
-      populate_layout
-      edit
-      render :action => 'edit'
-    end
-  end
-  
-  def update_task_estimate
-    update
-  end
-  
-  def destroy
-    task = Task.find(params[:id])
-    lower_item = task.lower_item
-    task.destroy
-    flash[:notice] = 'Task was successfully deleted.'
-    redirect_to :controller => 'periods', :action => :show, :id => task.period, :task => lower_item ? lower_item.id : nil
-  end
-  
-  def move_up
-    task = Task.find(params[:id])
-    task.move_higher
-    flash[:notice] = "Task #{@focus_id} was successfully moved."
-    redirect_to :controller => 'periods', :action => :show, :id => task.period, :task => task.id
-  end
-  
-  def move_down
-    task = Task.find(params[:id])
-    task.move_lower
-    redirect_to :controller => 'periods', :action => :show, :id => task.period, :task => task.id
-  end
-  
-  def move_to_top
-    task = Task.find(params[:id])
-    task.move_to_top
-    redirect_to :action => :list, :id => task
-  end
-  
-  def move_to_bottom
-    task = Task.find(params[:id])
-    task.move_to_bottom
-    redirect_to :action => :list, :id => task
-  end
-  
-  # Move the indicated task to the indicated position.
-  def move_to
-    params[:id] = $1 if params[:id] =~ /^task_(\d*)/
-    if params[:id] && task = Task.find(params[:id])
-      if params[:target_id]
-        if target_task = Task.find_by_id(params[:target_id])
-          if task.parent_id != target_task.parent_id
-            task.remove_from_list
-            task.position = nil
-            task.parent_id = target_task.parent_id
-            task.project_id = target_task.project_id
-            task.period_id = target_task.period_id
-          end
-          task.insert_at target_task.position
-        end
-      elsif params[:period_id] && params[:period_id].to_i != task.period_id
-        task.remove_from_list
-        task.period_id = params[:period_id]
-        task.insert_at 1
-        task.save!
-      else
-        flash[:notice] = "Target position is missing for move."
-      end
-    else
-      flash[:notice] = "Task not found"
-    end
-    redirect_to :controller => 'periods', :action => :show_no_layout, :id => task.period_id, :task => task.id
-  end
-  
-  def grab
-    @task = Task.find(params[:id])
-    @task.grab
-    detour = pop_detour
-    params.update(detour) if detour
-    render :template => '/tasks/_update.rjs' if request.xhr?
-  end
-  
-  def invite
-    @task = Task.find(params[:id])
-    @invitee = User.find(params[:user_id])
-    task_url = url_for(:action => 'edit', :id => @task.id)
-    grab_url = url_for(:action => 'grab', :id => @task.id)
-    TaskNotify.deliver_invite(current_user, @invitee, @task, task_url, grab_url)
-    detour = pop_detour
-    params.update(detour) if detour
-    render :template => '/tasks/_invite.rjs' if request.xhr?
-  end
-  
-  def release
-    @task = Task.find(params[:id])
-    @task.release
-    detour = pop_detour
-    params.update(detour) if detour
-    render :template => '/tasks/_update.rjs'
-  end
-  
-  def start_work
-    @task = Task.find(params[:id])
-    @task.start_work
-    detour = pop_detour
-    params.update(detour) if detour
-  end
-  
-  def end_work
-    @task = Task.find(params[:id])
-    next_quarter = Time.next_quarter
-    if started_work = @task.started_work
-      redirect_to({
-        :controller => 'works',
-        :action => :edit,
-        :id => started_work,
-            'work[task_id]' => @task.id,
-            'work[started_on]' => started_work.started_on.to_s,
-            'work[start_time]' => started_work.start_time.to_s,
-            'work[completed_at]' => [next_quarter, started_work.started_on.at(started_work.start_time || TimeOfDay.new(0, 0))].max.iso8601,
-            'work[hours]' => "%0.2f" % ((next_quarter - started_work.started_on.at(started_work.start_time || TimeOfDay.new(0, 0))).to_f / 3600),
-            'estimate[todo]' => @task.todo
-      })
-    else
-      @task.update_attributes(params[:task])
-      redirect_to({
-        :controller => 'works',
-        :action => :new, 
-            'work[task_id]' => @task.id,
-            'work[started_on]' => Time.previous_quarter.to_date.to_s,
-            'work[start_time]' => Time.previous_quarter.time_of_day.to_s,
-            'work[completed_at]' => next_quarter.iso8601,
-            'work[hours]' => "0.25",
-            'estimate[todo]' => @task.todo
-      })
-    end
-  end
-  
-  def specify
-    parent_task = Task.find(params[:id])
-    raise "Task is not open" unless parent_task.active? && (parent_task.period.nil? || parent_task.period.active_or_future?)
-    if parent_task.children.empty?
-      subtask_estimate = (parent_task.todo).ceil
-      no_of_subtasks = (parent_task.todo / subtask_estimate).to_i
-      subtask_estimate = parent_task.todo / no_of_subtasks
-       (1..no_of_subtasks).each do |index|
-        subtask = parent_task.children.build
-        subtask.description = "#{parent_task.description} ##{parent_task.children.size}"
-        subtask.initial_estimate = subtask_estimate
-        subtask.save!
-      end
-      redirect_to :controller => 'periods', :action => :show, :id => parent_task.period, :task => parent_task.children.first
-    else
-      average_estimate = parent_task.children.reduce {|value, task, size| value + (task.initial_estimate / size)}
-      subtask = parent_task.children.build
-      subtask.description = "#{parent_task.description} ##{parent_task.children.size}"
-      subtask.initial_estimate = average_estimate
-      subtask.save!
-      redirect_to :controller => 'periods', :action => :show, :id => parent_task.period, :task => parent_task.children.first
-    end
-    if started_work = parent_task.started_work
-      flash[:notice] = "Pågående arbeid er flyttet til subtask"
-      started_work.task = parent_task.children.last
-      started_work.save!
-    end
-  end
-  
-  def set_task_description
-    task = Task.find(params[:id])
-    task.description = params[:value]
-    task.save!
-    render :text => task.description
-  end
-  
-  def notes
-    @task = Task.find(params[:id])
-    render :layout => 'wide'
-  end
-  
-end