redmine_version_priorities 0.1.0

data/assets/javascripts/redmine_version_priorities.js

@@ -0,0 +1,63 @@
+jQuery(function($) {
+  $("#ajax-indicator").ajaxStart(function(){ $(this).show();  });
+  $("#ajax-indicator").ajaxStop(function(){ $(this).hide();  });
+
+  attachSortables = function() {
+    if (window.admin != true) {
+      return false;
+    }
+
+    attachPrioritizedSortables();
+    attachUnPrioritizedSortables();
+  },
+
+  attachPrioritizedSortables = function() {
+    $('#prioritized-versions ol').sortable({
+      cancel: 'a',
+      connectWith: ["#unprioritized-versions ul"],
+      placeholder: 'drop-accepted',
+      dropOnEmpty: true,
+      // Allow drag and drop inside the list
+      update: function (event, ui) {
+        if (ui.sender == null && event.target == this) {
+          saveOrder();
+        }
+      },
+      receive: function (event, ui) {
+        saveOrder();
+      }
+    });
+  },
+
+  attachUnPrioritizedSortables = function() {
+    $('#unprioritized-versions ul').sortable({
+      cancel: 'a',
+      connectWith: ["#prioritized-versions ol"],
+      placeholder: 'drop-accepted',
+      dropOnEmpty: true
+    });
+
+  },
+
+  saveOrder = function() {
+    var data = $('#prioritized-versions ol').sortable('serialize')
+
+    $.ajaxQueue.put('version_priorities.js', {
+      data: addAuthenticityToken(data),
+      success: function(response) {
+        $('#prioritized-versions').html(response);
+        attachPrioritizedSortables();
+      },
+      error: function(response) {
+        $("div.error").html("Error saving lists.  Please refresh the page and try again.").show();
+
+      }
+    });
+  },
+
+  addAuthenticityToken = function(data) {
+    return data + '&authenticity_token=' + encodeURIComponent(window._token);
+  },
+
+  attachSortables();
+});

data/assets/stylesheets/redmine_version_priorities.css

@@ -0,0 +1,17 @@
+
+.version {}
+li.version { clear: both; }
+.ui-sortable {cursor: move;}
+
+#prioritized-versions ol { padding-left: 35px; }
+#unprioritized-versions ul { list-style: none; padding-left: 15px;}
+
+/* item elements */
+li.version span.due_date { font-size: smaller; }
+li.version table.progress { display: inline; position: relative; float: right; }
+li.version p.pourcent { display: inline; position: relative; float: right; }
+
+h1.version-priority-title { margin-bottom: 15px; }
+
+
+.drop-accepted { background-color:#FFFFEE; height: 16px; margin-bottom:5px; border: 1px dashed #000000; }

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  version_priorities_title: "Version Priorities"
+  version_priorities_text_prioritized_versions: "Prioritized Versions"
+  version_priorities_text_unprioritized_versions: "Unprioritized Versions"
+  field_fixed_version_priority: "Version priority"

data/config/routes.rb

@@ -0,0 +1,3 @@
+ActionController::Routing::Routes.draw do |map|
+  map.resource :version_priorities
+end

data/init.rb

@@ -0,0 +1,38 @@
+require 'redmine'
+
+Redmine::Plugin.register :redmine_version_priorities do
+  name 'Version Priorities'
+  author 'Eric Davis'
+  url 'https://projects.littlestreamsoftware.com/projects/version-priorities'
+  author_url 'http://www.littlestreamsoftware.com'
+  description 'Allows versions to be prioritized'
+  version '0.1.0'
+
+  requires_redmine :version_or_higher => '0.9.0'
+
+  menu(:top_menu,
+       :version_priorities,
+       {:controller => 'version_priorities', :action => 'show'},
+       :caption => :version_priorities_title,
+       :if => Proc.new {
+         User.current.logged?
+       })
+
+  permission(:view_version_priorities, {:version_priorities => [:show]}, :public => true)
+
+end
+
+require 'dispatcher'
+Dispatcher.to_prepare :redmine_version_priorities do
+
+  require_dependency 'issue'
+  Issue.send(:include, RedmineVersionPriorities::Patches::IssuePatch)
+
+  require_dependency 'query'
+  unless Query.included_modules.include?(RedmineVersionPriorities::Patches::QueryPatch)
+    Query.send(:include, RedmineVersionPriorities::Patches::QueryPatch)
+  end
+
+  require_dependency 'version'
+  Version.send(:include, RedmineVersionPriorities::Patches::VersionPatch)
+end

data/lang/en.yml

@@ -0,0 +1,2 @@
+# English strings go here
+my_label: "My label"

data/lib/redmine_version_priorities/patches/issue_patch.rb

@@ -0,0 +1,27 @@
+module RedmineVersionPriorities
+  module Patches
+    module IssuePatch
+      def self.included(base)
+        base.extend(ClassMethods)
+
+        base.send(:include, InstanceMethods)
+        base.class_eval do
+          unloadable
+        end
+      end
+
+      module ClassMethods
+      end
+
+      module InstanceMethods
+        def fixed_version_priority
+          if fixed_version && fixed_version.priority.present?
+            fixed_version
+          else
+            l(:label_none)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redmine_version_priorities/patches/query_patch.rb

@@ -0,0 +1,37 @@
+module RedmineVersionPriorities
+  module Patches
+    module QueryPatch
+      def self.included(base)
+        base.extend(ClassMethods)
+
+        base.send(:include, InstanceMethods)
+        base.class_eval do
+          unloadable
+
+          add_available_column(QueryColumn.new(:fixed_version_priority,
+                                               :sortable => ["#{Version.table_name}.priority IS NULL",
+                                                             "#{Version.table_name}.priority",
+                                                             "#{Version.table_name}.effective_date",
+                                                             "#{Version.table_name}.name"],
+                                               :default_order => 'asc'))
+                                               
+        end
+      end
+
+      module ClassMethods
+        # Setter for +available_columns+ that isn't provided by the core.
+        def available_columns=(v)
+          self.available_columns = (v)
+        end
+
+        # Method to add a column to the +available_columns+ that isn't provided by the core.
+        def add_available_column(column)
+          self.available_columns << (column)
+        end
+      end
+
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/redmine_version_priorities/patches/version_patch.rb

@@ -0,0 +1,50 @@
+module RedmineVersionPriorities
+  module Patches
+    module VersionPatch
+      def self.included(base)
+        base.extend(ClassMethods)
+
+        base.send(:include, InstanceMethods)
+        base.class_eval do
+          unloadable
+          acts_as_list :column => 'priority'
+
+          named_scope :prioritized, :conditions => ["priority != 0 AND priority IS NOT NULL"], :order => 'priority ASC'
+          named_scope :unprioritized, :conditions => ["priority = 0 OR priority IS NULL"]
+
+          private
+
+          # Override acts_as_list to allow nil priorities
+          def add_to_list_bottom
+            self
+          end
+        end
+      end
+
+      module ClassMethods
+        def reprioritize(order)
+          ordered_ids = order.collect(&:to_i) if order.present?
+          ordered_ids ||= []
+          
+          # Removed versions
+          Version.visible.prioritized.each do |version|
+            unless ordered_ids.include?(version.id)
+              version.remove_from_list
+            end
+          end
+
+          # Sort
+          ordered_ids.each_with_index do |version_id, index|
+            version = Version.find_by_id(version_id)
+            version.insert_at( index + 1) if version
+          end
+
+        end
+        
+      end
+
+      module InstanceMethods
+      end
+    end
+  end
+end

data/test/functional/version_priorities_controller.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class VersionPrioritiesController < ActionController::TestCase
+end

data/test/integration/edit_version_priorities_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class EditVersionPrioritiesTest < ActionController::IntegrationTest
+  context "as a logged in user" do
+    setup do
+      @user = login_as_user
+    end
+
+    should_be_unauthorized("as a logged in user") {
+      put "/version_priorities.js"
+    }
+  end
+
+  context "as an administrator" do
+    setup do
+      @user = login_as_user
+      @user.update_attribute(:admin, true)
+
+      @project1 = Project.generate!
+      @project2 = Project.generate!
+      @version1 = Version.generate!(:project => @project1)
+      @version2 = Version.generate!(:project => @project2)
+    end
+
+    should "reprioritize the versions with a :html request" do
+      put "/version_priorities", :version => [@version2.id.to_s, @version1.id.to_s]
+
+      assert_response :redirect
+      follow_redirect!
+      assert_template 'version_priorities/show'
+      
+      assert_equal 2, @version1.reload.priority
+      assert_equal 1, @version2.reload.priority
+    end
+
+    should "reprioritize the versions with a :js request" do
+      put "/version_priorities.js", :version => [@version2.id.to_s, @version1.id.to_s]
+      assert_response :success
+
+      assert_equal 2, @version1.reload.priority
+      assert_equal 1, @version2.reload.priority
+    end
+
+    should "remove versions not in the list anymore" do
+      @version2.insert_at(1)
+      assert_equal 1, @version2.reload.priority
+      
+      put "/version_priorities.js", :version => [@version1.id.to_s]
+      assert_response :success
+
+      assert_equal nil, @version2.reload.priority
+    end
+
+    should "remove all versions when the list is empty" do
+      @version2.insert_at(1)
+      assert_equal 1, @version2.reload.priority
+      @version1.insert_at(2)
+      assert_equal 2, @version1.reload.priority
+      
+      put "/version_priorities.js"
+      assert_response :success
+
+      assert_equal nil, @version1.reload.priority
+      assert_equal nil, @version2.reload.priority
+    end
+  end
+  
+  def login_as_user
+    user = User.generate!(:login => 'existing', :password => 'existing', :password_confirmation => 'existing', :admin => false)
+    visit "/login"
+    fill_in 'Login', :with => 'existing'
+    fill_in 'Password', :with => 'existing'
+    click_button 'login'
+    assert_response :success
+    assert User.current.logged?
+
+    user
+  end
+end

data/test/integration/view_version_priorities_test.rb

@@ -0,0 +1,90 @@
+require 'test_helper'
+
+class ViewVersionPrioritiesTest < ActionController::IntegrationTest
+  should "not show the menu item to users not logged in" do
+    visit "/"
+    assert_response :success
+    assert_select "#top-menu a.version-priorities", :count => 0
+  end
+
+  should "show the menu item to logged in users" do
+    login_as_user
+    
+    visit "/"
+    assert_response :success
+    assert_select "#top-menu a.version-priorities", :count => 1
+  end
+
+  should "allow all logged in users to visit the prioritized versions panel" do
+    login_as_user
+
+    visit '/'
+    click_link "Version Priorities"
+    assert_response :success
+    assert_equal "/version_priorities", current_url
+  end
+
+  should "allow all logged in users to see the unprioritized versions" do
+    @user = login_as_user
+    @project1 = Project.generate!
+    @project2 = Project.generate!
+    @version1 = Version.generate!(:project => @project1)
+    @version2 = Version.generate!(:project => @project2)
+    @role = Role.generate!(:permissions => [:view_issues])
+    Member.generate!(:principal => @user, :roles => [@role], :project => @project1)
+    Member.generate!(:principal => @user, :roles => [@role], :project => @project2)
+    
+    visit "/version_priorities"
+
+    assert_select "#unprioritized-versions" do
+      assert_select "li" do
+        assert_select "a", :text => /#{@version1.name}/
+        assert_select "span", :text => /#{@version1.description}/
+      end
+
+      assert_select "li" do
+        assert_select "a", :text => /#{@version2.name}/
+        assert_select "span", :text => /#{@version2.description}/
+      end
+    end
+    
+  end
+
+  should "allow all logged in users to see the prioritized versions" do
+    @user = login_as_user
+    @project1 = Project.generate!
+    @project2 = Project.generate!
+    @version1 = Version.generate!(:project => @project1, :priority => 1)
+    @version2 = Version.generate!(:project => @project2, :priority => 2)
+    @role = Role.generate!(:permissions => [:view_issues])
+    Member.generate!(:principal => @user, :roles => [@role], :project => @project1)
+    Member.generate!(:principal => @user, :roles => [@role], :project => @project2)
+    
+    visit "/version_priorities"
+
+    assert_select "#prioritized-versions" do
+      assert_select "li" do
+        assert_select "a", :text => /#{@version1.name}/
+        assert_select "span", :text => /#{@version1.description}/
+      end
+
+      assert_select "li" do
+        assert_select "a", :text => /#{@version2.name}/
+        assert_select "span", :text => /#{@version2.description}/
+      end
+    end
+    
+  end
+
+  def login_as_user
+    user = User.generate!(:login => 'existing', :password => 'existing', :password_confirmation => 'existing', :admin => false)
+    visit "/login"
+    fill_in 'Login', :with => 'existing'
+    fill_in 'Password', :with => 'existing'
+    click_button 'login'
+    assert_response :success
+    assert User.current.logged?
+
+    user
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,52 @@
+# Load the normal Rails helper
+require File.expand_path(File.dirname(__FILE__) + '/../../../../test/test_helper')
+
+# Ensure that we are using the temporary fixture path
+Engines::Testing.set_fixture_path
+
+require "webrat"
+
+Webrat.configure do |config|
+  config.mode = :rails
+end
+
+class Test::Unit::TestCase
+  def setup
+    setup_anonymous_role
+    setup_non_member_role
+  end
+  
+  def setup_anonymous_role
+    begin
+      @anon_role = Role.anonymous
+    rescue
+      @anon_role = Role.generate!
+      @anon_role.update_attribute(:builtin, Role::BUILTIN_ANONYMOUS)
+    end
+  end
+
+  def setup_non_member_role
+    begin
+      @anon_role = Role.non_member
+    rescue
+      @non_member_role = Role.generate!
+      @non_member_role.update_attribute(:builtin, Role::BUILTIN_NON_MEMBER)
+    end
+  end
+
+  def self.should_be_unauthorized(description, &block)
+    context description do
+      should "render the unauthorized template" do
+        instance_eval &block
+        assert_template 'common/403'
+      end
+      
+      should "respond with unauthorized" do
+        instance_eval &block
+        assert_response 403
+      end
+
+    end
+  end
+
+end