houston-roadmaps 0.1.0

data/app/controllers/houston/roadmaps/milestones_controller.rb

@@ -0,0 +1,118 @@
+module Houston
+  module Roadmaps
+    class MilestonesController < ApplicationController
+      attr_reader :milestone
+
+      layout "houston/roadmaps/application"
+
+      before_filter :find_milestone, only: [:show, :update, :close, :add_ticket, :create_ticket, :remove_ticket, :update_order]
+
+
+      def show
+        authorize! :read, milestone
+        @project = milestone.project
+        @title = "#{milestone.name} • #{@project.name}"
+        @tickets = milestone.tickets.includes(:project, :tasks, :reporter)
+        @open_tickets = @project.tickets.open.includes(:tasks, :reporter)
+      end
+
+
+      def create
+        project = Project.find(params[:projectId])
+        authorize! :create, project.milestones.build
+        milestone = project.create_milestone!(milestone_attributes)
+        if milestone.persisted?
+          render json: Houston::Roadmaps::MilestonePresenter.new(milestone), status: :created
+        else
+          render json: milestone.errors, status: :unprocessable_entity
+        end
+      end
+
+
+      def update
+        authorize! :update, milestone
+        milestone.updated_by = current_user if milestone.respond_to?(:updated_by=)
+        if milestone.update_attributes(milestone_attributes)
+          render json: Houston::Roadmaps::MilestonePresenter.new(milestone)
+        else
+          render json: milestone.errors, status: :unprocessable_entity
+        end
+      end
+
+
+      def close
+        authorize! :update, milestone
+        milestone.close!
+        render json: {}
+      end
+
+
+      def add_ticket
+        authorize! :update_tickets, milestone
+        ticket = Ticket.find params[:ticket_id]
+        ticket.update_attribute :milestone_id, milestone.id
+        head :ok
+      end
+
+
+      def create_ticket
+        authorize! :update_tickets, milestone
+        authorize! :create, milestone.tickets.build
+
+        ticket = project.create_ticket!(
+          milestone_id: milestone.id,
+          type: "Feature",
+          summary: params[:summary],
+          reporter: current_user)
+
+        if ticket.persisted?
+          render json: TicketPresenter.new(ticket), status: :created, location: ticket.ticket_tracker_ticket_url
+        else
+          render json: ticket.errors, status: :unprocessable_entity
+        end
+      end
+
+
+      def remove_ticket
+        authorize! :update_tickets, milestone
+        ticket = Ticket.find params[:ticket_id]
+        ticket.update_attribute :milestone_id, nil
+        head :ok
+      end
+
+
+      def update_order
+        authorize! :update_tickets, milestone
+
+        ids = Array.wrap(params[:order]).map(&:to_i).reject(&:zero?)
+
+        ::Ticket.transaction do
+          milestone.tickets.where(::Ticket.arel_table[:id].not_in(ids))
+            .update_all("extended_attributes = extended_attributes || 'milestoneSequence=>NULL'::hstore")
+
+          ids.each_with_index do |id, i|
+            ::Ticket.unscoped.where(id: id).update_all("extended_attributes = extended_attributes || 'milestoneSequence=>#{i+1}'::hstore")
+          end
+        end
+
+        head :ok
+      end
+
+
+    private
+
+      def find_milestone
+        @milestone = Milestone.unscoped.find(params[:id])
+      end
+
+      def project
+        milestone.project
+      end
+
+      def milestone_attributes
+        params.fetch(:milestone).pick(:name, :band, :lanes, :start_date, :end_date, :locked, :goal, :feedback_query)
+      end
+
+    end
+  end
+end

data/app/controllers/houston/roadmaps/project_goals_controller.rb

@@ -0,0 +1,24 @@
+module Houston
+  module Roadmaps
+    class ProjectGoalsController < ApplicationController
+      layout "houston/roadmaps/application"
+      before_filter :find_project
+
+
+      def index
+        authorize! :read, Milestone.new(project_id: @project.id)
+
+        @title = "Goals for #{@project.name}"
+        @milestones = @project.milestones
+      end
+
+
+    private
+
+      def find_project
+        @project = Project.find_by_slug! params[:project_slug]
+      end
+
+    end
+  end
+end

data/app/controllers/houston/roadmaps/roadmap_milestones_controller.rb

@@ -0,0 +1,36 @@
+module Houston
+  module Roadmaps
+    class RoadmapMilestonesController < RoadmapsController
+      layout "houston/roadmaps/application"
+      before_filter :find_roadmap
+
+
+      def index
+        authorize! :read, Roadmap
+        render json: Houston::Roadmaps::RoadmapMilestonePresenter.new(@roadmap.milestones)
+      end
+
+
+      def update
+        authorize! :update, @roadmap
+
+        @roadmap.commits.create!(
+          user: current_user,
+          message: params[:message],
+          milestone_changes: params.fetch(:roadmap, {}).values)
+
+        head :ok
+      rescue ActiveRecord::RecordInvalid
+        render json: $!.record.errors, status: 422
+      end
+
+
+    private
+
+      def find_roadmap
+        @roadmap = Roadmap.find params[:id]
+      end
+
+    end
+  end
+end

data/app/controllers/houston/roadmaps/roadmaps_controller.rb

@@ -0,0 +1,77 @@
+module Houston
+  module Roadmaps
+    class RoadmapsController < ApplicationController
+      layout "houston/roadmaps/application"
+      before_filter :find_roadmap, only: [:show, :history, :edit, :update, :update_milestones, :destroy]
+
+
+      def index
+        authorize! :read, Roadmap
+        @title = "Roadmaps"
+        @roadmaps = Roadmap.all.preload(:projects, :milestones => {:milestone => :project}).order(:name)
+      end
+
+
+      def show
+        authorize! :read, @roadmap
+        @title = @roadmap.name
+        @goals = @roadmap.projects.goals
+        @milestones = @roadmap.milestones
+
+        render template: "houston/roadmaps/roadmaps/show_editable" if can?(:update, @roadmap)
+      end
+
+
+      def history
+        authorize! :read, @roadmap
+        @title = "#{@roadmap.name} History"
+
+        @commits = @roadmap.commits.order(created_at: :desc)
+        @commit_id = params[:commit_id].to_i
+
+        @milestones = @roadmap.milestones.including_destroyed
+        @markers = Houston::Roadmaps.config.markers
+      end
+
+
+      def edit
+        authorize! :update, @roadmap
+      end
+
+
+      def update
+        authorize! :update, @roadmap
+        if @roadmap.update_attributes params[:roadmap]
+          redirect_to roadmaps_url, notice: "Roadmap created"
+        else
+          render action: :edit
+        end
+      end
+
+
+      def new
+        authorize! :create, Roadmap
+        @roadmap = Roadmap.new
+      end
+
+
+      def create
+        authorize! :create, Roadmap
+        @roadmap = Roadmap.create params[:roadmap]
+        if @roadmap.persisted?
+          redirect_to roadmaps_url, notice: "Roadmap created"
+        else
+          render action: :new
+        end
+      end
+
+
+    protected
+
+      def find_roadmap
+        @roadmap = Roadmap.find params[:id]
+      end
+
+    end
+  end
+end

data/app/helpers/houston/roadmaps/application_helper.rb

@@ -0,0 +1,4 @@
+module Houston::Roadmaps
+  module ApplicationHelper
+  end
+end

data/app/models/roadmap.rb

@@ -0,0 +1,9 @@
+class Roadmap < ActiveRecord::Base
+
+  has_many :milestones, class_name: "RoadmapMilestone"
+  has_many :commits, class_name: "RoadmapCommit"
+  has_and_belongs_to_many :projects
+
+  validates :name, presence: true
+
+end

data/app/models/roadmap_commit.rb

@@ -0,0 +1,35 @@
+class RoadmapCommit < ActiveRecord::Base
+  attr_accessor :milestone_changes
+
+  belongs_to :roadmap
+  belongs_to :user
+  has_many :milestone_versions, class_name: "RoadmapMilestoneVersion"
+
+  validates :user, :message, :roadmap, :milestone_changes, presence: true
+
+  after_save :commit_milestone_changes
+
+private
+
+  def commit_milestone_changes
+    milestone_changes.each do |change|
+      id = change.delete(:id)
+      remove = change.delete(:removed)
+      milestone = id && roadmap.milestones.find_by_id(id)
+      if remove == true || remove == "true"
+        milestone.update_attributes!(destroyed_at: Time.now) if milestone
+      else
+        milestone_attributes = change.pick(:band, :lanes, :start_date, :end_date)
+        if milestone
+          milestone.update_attributes!(milestone_attributes)
+        else
+          milestone = roadmap.milestones.create!(
+            milestone_attributes.merge(milestone_id: change[:milestoneId]))
+        end
+      end
+      version = milestone.versions.at(milestone.version)
+      version.update_column :roadmap_commit_id, self.id if version
+    end
+  end
+
+end

data/app/models/roadmap_milestone.rb

@@ -0,0 +1,29 @@
+class RoadmapMilestone < ActiveRecord::Base
+
+  default_scope { where(destroyed_at: nil).preload(:milestone) }
+
+  belongs_to :roadmap
+  belongs_to :milestone, -> { unscope(where: :destroyed_at) }
+
+  validates :roadmap_id, :milestone_id, :band, :start_date, :end_date, :lanes, presence: true
+
+  versioned only: [:start_date, :end_date, :band, :lanes, :destroyed_at], class_name: "RoadmapMilestoneVersion", initial_version: true
+
+  delegate :project,
+           :project_id,
+           :name,
+           :completed?,
+           to: :milestone
+
+
+  class << self
+    def including_destroyed
+      unscope(where: :destroyed_at)
+    end
+
+    def during(range)
+      where(arel_table[:start_date].lteq(range.end)).where(arel_table[:end_date].gteq(range.begin))
+    end
+  end
+
+end

data/app/models/roadmap_milestone_version.rb

@@ -0,0 +1,8 @@
+class RoadmapMilestoneVersion < VestalVersions::Version
+  self.table_name = "roadmap_milestone_versions"
+
+  attr_accessor :user_name
+
+  belongs_to :roadmap_commit
+
+end

data/app/presenters/houston/roadmaps/milestone_api_presenter.rb

@@ -0,0 +1,27 @@
+class Houston::Roadmaps::MilestoneApiPresenter
+
+  def initialize(milestones)
+    @milestones = OneOrMany.new(milestones)
+  end
+
+  def as_json(*args)
+    @milestones.map(&method(:to_hash))
+  end
+
+  def to_hash(milestone)
+    project = milestone.project
+    { id: milestone.id,
+      name: milestone.name,
+      projectId: project.id,
+      projectName: project.name,
+      projectSlug: project.slug,
+      tickets: milestone.tickets.map { |ticket| {
+        id: ticket.id,
+        number: ticket.number,
+        summary: ticket.summary
+      } },
+      startDate: milestone.start_date,
+      endDate: milestone.end_date }
+  end
+
+end

data/app/presenters/houston/roadmaps/milestone_presenter.rb

@@ -0,0 +1,74 @@
+class Houston::Roadmaps::MilestonePresenter
+
+  def initialize(milestones)
+    @milestones = OneOrMany.new(milestones)
+  end
+
+  def as_json(*args)
+    @milestones.map(&method(:to_hash))
+  end
+
+  def to_hash(milestone)
+    project = milestone.project
+    { id: milestone.id,
+      name: milestone.name,
+      roadmaps: milestone.roadmap_ids,
+      projectId: project.id,
+      projectColor: project.color,
+      projectName: project.name,
+      tickets: milestone.tickets_count,
+      ticketsCompleted: milestone.closed_tickets_count,
+      percentComplete: percent_complete(milestone),
+      completed: milestone.completed?,
+      band: milestone.band,
+      lanes: milestone.lanes,
+      locked: milestone.locked? || milestone.completed?,
+      startDate: milestone.start_date,
+      endDate: milestone.end_date,
+      removed: milestone.destroyed_at.present? }
+  end
+
+private
+
+  def percent_complete(milestone)
+    percent_complete_by_ticket.fetch(milestone.id, 0)
+  end
+
+  def percent_complete_by_ticket
+    @percent_complete_by_ticket ||= Hash[Milestone.connection.select_rows(<<-SQL)
+      SELECT
+        tickets.milestone_id,
+        tickets.id,
+        tickets.closed_at IS NOT NULL "closed",
+        all_tasks.count,
+        completed_tasks.count
+      FROM tickets
+      LEFT OUTER JOIN (
+        SELECT ticket_id, COUNT(id) "count"
+        FROM tasks
+        GROUP BY ticket_id)
+      AS all_tasks
+        ON all_tasks.ticket_id=tickets.id
+      LEFT OUTER JOIN (
+        SELECT ticket_id, COUNT(id) "count"
+        FROM tasks
+        WHERE tasks.completed_at IS NOT NULL
+        GROUP BY ticket_id)
+      AS completed_tasks
+        ON completed_tasks.ticket_id=tickets.id
+      WHERE tickets.destroyed_at IS NULL
+      AND tickets.milestone_id IN (#{milestone_ids.join(", ")})
+    SQL
+      .map { |milestone_id, _, closed, tasks, completed_tasks|
+        [ milestone_id.to_i,
+          closed == "t" ? 1.0 : (completed_tasks.to_f / (tasks.to_i + 1)) ] }
+      .group_by { |(milestone_id, _)| milestone_id }
+      .map { |(milestone_id, tickets)|
+        [milestone_id, (tickets.sum { |(_, percent)| percent } / tickets.length)] }]
+  end
+
+  def milestone_ids
+    @milestone_ids ||= Array(@milestones.map(&:id))
+  end
+
+end