redmine_extensions 0.0.1 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 457ef3eb0948c0760fabb108a5f4d6420fdc4cb7
-  data.tar.gz: fc6ac9554f09709835376a47817d8341997a9446
+  metadata.gz: adfbe34a5f7280adf2a9e9239d89d017f90a4542
+  data.tar.gz: 55d4a91f1c9b4e4447f11fd34301c2aa4b6b0412
 SHA512:
-  metadata.gz: b770df66e5c6f6bfb7035a17a6f93eabfda472caa8d18f50c8eafec1e96bf73746b1273ad322ea0cfa051a3baa3b9f7ee4c4f5e656cbb28fa7c5f4b7e346f5ea
-  data.tar.gz: b60d1d9eaef7a7587c8649026c2f7a8a347dad6428f107840913a55d666f28d74573858cebea7ce6d08c8a877064e027921ccd9b93738f3616e935748ee2cff1
+  metadata.gz: cd8ed37998e18d586e5df7fa4c6a7ed613bd7c653a936f0ccdd68283aaf71d273d4347310adc5d20efc0ebb91bd4b9f5091a286d9df2546c96848a658c8e52cd
+  data.tar.gz: e66976e36b0300ec36f5d749b991fc3ef09ffb77169ca64fa5a6250169a6d6b5c26fd11dd4ee707d393c87882bda78c15439809ca6e01ff4ffbfc2a879555446

data/Rakefile

@@ -5,23 +5,24 @@ rescue LoadError
   puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
 end
 
-require 'rdoc/task'
-
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'RedmineExtensions'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+begin
+  require 'rdoc/task'
+
+  desc "Generate documentation for the plugin."
+  Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_dir = "rdoc"
+    rdoc.title = "RedmineExtensions #{RedmineExtensions::VERSION}"
+    rdoc.rdoc_files.include("README*")
+    rdoc.rdoc_files.include("lib/**/*.rb")
+  end
+rescue LoadError
+  puts 'RDocTask is not supported for this platform'
 end
 
-APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path("../spec/redmine/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 
-
-load 'rails/tasks/statistics.rake'
-
-
+# load 'rails/tasks/statistics.rake'
 
 Bundler::GemHelper.install_tasks
 
@@ -32,6 +33,9 @@ require 'rspec/core/rake_task'
 
 desc "Run all specs in spec directory (excluding plugin specs)"
 
-RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.exclude_pattern = 'spec/redmine/**/*_spec.rb'
+end
 
 task :default => :spec

data/app/assets/javascripts/redmine_extensions/jquery.easy_query.js

@@ -0,0 +1,235 @@
+(function( $, undefined ) {
+  $.widget('easy.easy_query', {
+    options: {
+      modul_uniq_id: null
+    },
+
+    _create: function() {
+      var that = this;
+
+      this.modul_uniq_id = this.options.modul_uniq_id || this.element.attr('id') || '';
+      this.filters_container = $('.filters-table', this.element);
+
+      $(this.element).on('change', '.add_filter_select', function(evt){
+          var select = $(this),
+            field = select.val();
+
+          $('[id="' + that.modul_uniq_id + 'tr_' + field + '"]').show();
+          $('[id="' + that.modul_uniq_id + 'cb_' + field + '"]').prop('checked', true);
+          that.toggleFilter(field);
+          select[0].selectedIndex = 0;
+          $("option[value='" + field + "']", select).prop('disabled', true);
+      });
+
+      $("input[name='query[visibility]']", this.element).change(function(){
+        var roles_checked = $('.query_visibility_roles', that.element).is(':checked');
+        var private_checked = $('.query_visibility_private', that.element).is(':checked');
+        $("input[name='query[role_ids][]'][type=checkbox]").attr('disabled', !roles_checked);
+        if (!private_checked) $("input.disable-unless-private", that.element).attr('checked', false);
+        $("input.disable-unless-private").attr('disabled', !private_checked);
+      }).trigger('change');
+
+      /* filters showing and hiding evts */
+      if(this.filters_container.length > 0) {
+        $.each(this.filters_container.data('enabled'), function(){
+          that.toggleFilter(this);
+        });
+
+        $(this.filters_container).on('change', '.filter_select_operator', function(evt) {
+          that.toggleOperator( $(this).data('field') );
+        });
+        $(this.filters_container).on('change', '.filters_checkbox', function(evt) {
+          that.toggleFilter( $(this).val() );
+        });
+      }
+
+      /* QUERY APPLY */
+      $('.filter_buttons .apply-link', this.element).click(function(evt){
+        var $this = $(this);
+        evt.preventDefault();
+        that.applyEasyQueryFilters($this.attr('href'), $($this.data('toserialize')) );
+      });
+      $('.filter_buttons .save-link', this.element).click(function(evt){
+        var query_form_id = '#'+that.modul_uniq_id+'query_form';
+        evt.preventDefault();
+        that.applyEasyQueryFilters($(query_form_id).attr('action'), $(query_form_id + ' .query-form-addtional-hidden-fields input:hidden'));
+      });
+    },
+
+    toggleFilter: function(field) {
+      var check_box = $('#' + this.modul_uniq_id + 'cb_' + field);
+
+      if (check_box.is(':checked')) {
+          $('#' + this.modul_uniq_id + "operators_" + field).show();
+          this.toggleOperator(field, this.modul_uniq_id);
+      } else {
+          $('#' + this.modul_uniq_id + "operators_" + field).hide();
+          $('#' + this.modul_uniq_id + "div_values_" + field).hide();
+      }
+    },
+
+
+    toggleOperator: function(field) {
+        var operator = $('#' + this.modul_uniq_id + "operators_" + field);
+        if (typeof(operator.val()) === 'undefined') {
+            $('#' + this.modul_uniq_id + "div_values_" + field).show();
+        } else {
+            switch (operator.val()) {
+                case "!*":
+                case "*":
+                case "t":
+                case "ld":
+                case "w":
+                case "lw":
+                case "l2w":
+                case "m":
+                case "lm":
+                case "y":
+                case "o":
+                case "c":
+                    this.enableValues(field, []);
+                    break;
+                case "><":
+                    this.enableValues(field, [0, 1]);
+                    break;
+                case "<t+":
+                case ">t+":
+                case "><t+":
+                case "t+":
+                case ">t-":
+                case "<t-":
+                case "><t-":
+                case "t-":
+                    this.enableValues(field, [2]);
+                    break;
+                case "=p":
+                case "=!p":
+                case "!p":
+                    this.enableValues(field, [1]);
+                    break;
+                default:
+                    this.enableValues(field, [0]);
+                    break;
+            }
+        }
+    },
+
+    enableValues: function(field, indexes) {
+        var div_values = $('#' + this.modul_uniq_id + "div_values_" + field);
+        div_values.find(".values_" + field).each(function(i) {
+            if (indexes.indexOf(i) > -1) {
+                $(this).prop('disabled', false).parent('span').show();
+            } else {
+                $(this).prop('disabled', true).val('').parent('span').hide();
+            }
+        });
+        div_values.toggle(indexes.length > 0);
+    },
+
+    getEasyQueryFilterValue: function(filter_value_element) {
+        var filter_value = '',
+                val_el_val = [];
+
+        if (filter_value_element.length > 0) {
+            if (filter_value_element[0].tagName === 'SPAN') {
+                filter_value_element.find('input[type="hidden"]').each(function(i, el) {
+                    val_el_val.push($(el).val());
+                });
+            } else if (filter_value_element[0].tagName === 'SELECT') {
+                var value = filter_value_element.val();
+                if ($.isArray(value)) {
+                    $.merge(val_el_val, value)
+                } else {
+                    val_el_val.push(value);
+                }
+            } else if (filter_value_element.is("input:radio")) {
+                val_el_val.push(filter_value_element.filter(":checked").val());
+            } else {
+                filter_value_element.each(function() {
+                    val_el_val.push($(this).val());
+                });
+            }
+            filter_value = val_el_val && val_el_val.join('|');
+        }
+        return filter_value;
+    },
+
+    getEasyQueryFiltersForURL: function() {
+        var modul_uniq_id = this.modul_uniq_id,
+          that = this,
+          filter_values = [];
+
+        $('#' + modul_uniq_id + 'filters table.filters-table input:checkbox[name*="fields"]').filter(":checked").each(function(idx, el) {
+            var filter_value = '';
+            var el_val = el.value.replace('.', '_');
+            var operator = $('#' + modul_uniq_id + 'operators_' + el_val).val();
+            var val_el_single_value = $("tr#" + modul_uniq_id + "tr_"+el_val).children('td:last').find("input:not(.ui-autocomplete-input), select");
+            var val_el_two_values_1 = $('#' + modul_uniq_id + 'values_' + el_val + '_1');
+            var val_el_two_values_2 = $('#' + modul_uniq_id + 'values_' + el_val + '_2');
+            if (operator === undefined) { operator = '='; }
+
+            if (['=', '!', 'o', 'c', '*', '!*', '~', '!~', '^~', '=p', '=!p', '!p'].indexOf(operator) >= 0 && val_el_single_value.length > 0) {
+                filter_value = that.getEasyQueryFilterValue(val_el_single_value);
+            } else if (['=', '>=', '<=', '><', '!*', '*'].indexOf(operator) >= 0 && val_el_two_values_1.length > 0 && val_el_two_values_2.length > 0) {
+                filter_value = that.getEasyQueryFilterValue(val_el_two_values_1);
+                filter_value += '|' + that.getEasyQueryFilterValue(val_el_two_values_2);
+            } else if (operator === '') {
+                var p1 = $('#' + modul_uniq_id + '' + el_val + '_date_period_1');
+                if (p1 && p1.is(':checked')) {
+                    filter_value = $('#' + modul_uniq_id + 'values_' + el_val + '_period').val();
+                    if (filter_value.indexOf('n_days') !== -1) {
+                        filter_value += '|' + $('#' + modul_uniq_id + 'values_' + el_val + '_period_days').val();
+                    }
+                }
+                var p2 = $('#' + modul_uniq_id + '' + el_val + '_date_period_2');
+                if (p2 && p2.is(':checked')) {
+                    filter_value = $('#' + modul_uniq_id + '' + el_val + '_from').val();
+                    filter_value += '|' + $('#' + modul_uniq_id + '' + el_val + '_to').val();
+                }
+            }
+
+            if (!filter_value) { filter_value = '0'; }
+            filter_values.push(el.value + '=' + encodeURIComponent(operator + filter_value));
+        });
+        this._selectAllOptions(modul_uniq_id + 'selected_columns');
+        if ($('#selected_project_columns').length > 0)
+            this._selectAllOptions(modul_uniq_id + 'selected_project_columns');
+        filter_values.push($('#' + modul_uniq_id + 'selected_columns').serialize());
+        var show_sum_val = $('#' + modul_uniq_id + 'show_sum_row_1').serialize();
+        if (show_sum_val.length === 0) {
+            show_sum_val = $('#' + modul_uniq_id + 'show_sum_row_0').serialize();
+        }
+        var options = $(':input', $((modul_uniq_id === '' ? '' : '#' + modul_uniq_id) + ' .easy_query_additional_options')).serialize();
+        filter_values.push(show_sum_val);
+        filter_values.push(options);
+        filter_values.push($('#' + modul_uniq_id + 'group_by').serialize());
+        filter_values.push($('select.serialize, input.serialize', $('#' + modul_uniq_id + 'filters').closest('form')).serialize());
+        // TODO razeni
+        return filter_values.join('&');
+    },
+
+    applyEasyQueryFilters: function(url, additional_elements_to_serialize) {
+        if (url.indexOf('?') >= 0) {
+            url += '&';
+        } else {
+            url += '?';
+        }
+
+        var target_url = url + this.getEasyQueryFiltersForURL();
+
+        if (additional_elements_to_serialize && (additional_elements_to_serialize instanceof jQuery)) {
+            target_url += '&' + additional_elements_to_serialize.serialize();
+        }
+
+        window.location = target_url;
+    },
+
+    _selectAllOptions: function(id)
+    {
+        var select = $('#'+id);
+        select.children('option').prop('selected', true);
+    }
+
+  });
+
+})(jQuery);

data/app/assets/javascripts/redmine_extensions/redmine_extensions.js

@@ -0,0 +1,217 @@
+REDMINE_EXTENSIONS = {
+
+  toggleDiv: function(el_or_id) {
+    var el;
+    if (typeof(el_or_id) === 'string') {
+        el = $('#' + el_or_id);
+    } else {
+        el = el_or_id;
+    }
+
+    el.toggleClass('collapsed').slideToggle('fast');
+  },
+
+  toggleDivAndChangeOpen: function(toggleElementId, changeOpenElement) {
+    REDMINE_EXTENSIONS.toggleDiv(toggleElementId);
+    $(changeOpenElement).toggleClass('open');
+  },
+
+  toggleFilterButtons: function(elButtonsID, elFilter1ID, elFilter2ID)
+  {
+      var elButtons = $('#' + elButtonsID);
+      var elFilter1 = $('#' + elFilter1ID);
+      var elFilter2 = $('#' + elFilter2ID);
+
+      if (elFilter1.hasClass('collapsed') && elFilter2.hasClass('collapsed')) {
+          elButtons.slideUp('slow');
+      } else {
+          elButtons.slideDown('slow');
+      }
+  }
+
+};
+
+(function($, undefined) {
+
+    var plugin = 'easygrouploader';
+    var defaults = {
+        next_button_cols: 1,
+        load_opened: false,
+        load_limit: 25,
+        texts: {
+            'next': 'Next',
+        }
+    };
+
+    $.fn[plugin] = function(options, methodParams) {
+        $.each($(this), function(idx) {
+            var instance = $(this).data('plugin_' + plugin);
+            if (!instance) {
+                instance = new EasyGroupLoader(this, options);
+                $(this).data('plugin_' + plugin, instance);
+            } else if (typeof options === 'string') {
+                switch (options) {
+                    case 'load_groups':
+                        if (instance.options.load_opened)
+                            instance.load_all_groups();
+                }
+            }
+        });
+        return $(this);
+    };
+
+
+    function EasyGroupLoader(elem, options) {
+        this.groupsContainer = $(elem);
+        this.options = $.extend({}, defaults, options);
+        this.loadUrl = options.loadUrl || elem.data('url');
+        this.texts = this.options.texts;
+
+        this.init();
+    }
+
+    EasyGroupLoader.prototype.init = function()
+    {
+        var self = this;
+        this.groupsContainer.on('click', '.group .expander', function(evt) {
+            var $row = $(this).closest('tr.group');
+            var group = $row.data('group') || new Group(self, $row);
+
+            if (!group.loaded) {
+                if (!group.header.hasClass('group-loaded')) {
+                  group.load();
+                  group.toggle();
+                }
+            } else {
+                group.toggle();
+            }
+
+        });
+        if (this.options.load_opened)
+            this.load_all_groups();
+    };
+
+    EasyGroupLoader.prototype.initInlineEdit = function()
+    {
+        $('.multieditable-container:not(.multieditable-initialized)', this.groupsContainer).each(function() {
+            initInlineEditForContainer(this);
+        });
+        initProjectEdit();
+        initEasyAutocomplete();
+    };
+
+    EasyGroupLoader.prototype.load_all_groups = function()
+    {
+        var group;
+        var self = this;
+        var groups_to_load = [];
+        var entity_count = 0;
+        $('.group', this.groupsContainer).not('.group-loaded').each(function() {
+            group = $(this).data('group') || new Group(self, $(this));
+            if (!group.loaded) {
+                groups_to_load.push(group);
+                entity_count += group.count;
+            }
+            if (entity_count >= self.options.load_limit) {
+                self.load_groups(groups_to_load);
+                entity_count = 0;
+                groups_to_load = [];
+            }
+        });
+        if (groups_to_load.length > 0) {
+            this.load_groups(groups_to_load);
+        }
+    };
+
+    EasyGroupLoader.prototype.load_groups = function(groups_to_load) {
+        var self = this;
+        var group_names = groups_to_load.map(function(group) {
+            return group.group_name
+        });
+        var url = EPExtensions.setAttrToUrl(this.loadUrl, 'group_to_load', group_names);
+        $.get(url, function(data, textStatus, request) {
+            var parsed = typeof data == 'object' ? data : $.parseJSON(data);
+
+            $.each(groups_to_load, function(idx, group) {
+                group.parseData(parsed[group.group_name]);
+                group.toggle();
+            });
+            self.initInlineEdit();
+        });
+    };
+
+    function Group(loader, header)
+    {
+        this.loader = loader;
+        this.header = header;
+        this.header.data('group', this);
+        this.group_name = this.header.data('group-name');
+        this.load_url = EPExtensions.setAttrToUrl(this.loader.loadUrl, 'group_to_load', this.group_name);
+        this.count = parseInt(this.header.data('entity-count'));
+        this.pages = this.header.data('pages') || 1;
+        this.loaded = this.header.hasClass('preloaded');
+    }
+
+    Group.prototype.toggle = function() {
+        EPExtensions.issuesToggleRowGroup(this.header);
+    };
+
+    Group.prototype.load = function() {
+        var $hrow = this.header;
+        var self = this;
+
+        if (!$hrow.hasClass('group-loaded')) {
+            $hrow.addClass('group-loaded');
+            $.get(this.load_url, function(data, textStatus, request) {
+                self.parseData(data);
+                self.loader.initInlineEdit();
+            });
+        }
+    };
+
+    Group.prototype.parseData = function(data) {
+        var $hrow = this.header;
+
+        this.rows = $(data);
+        $hrow.after(this.rows);
+        $hrow.data('group-page', 1);
+        this.loaded = true;
+        if (this.pages > 1) {
+            this.createNextButton();
+            // .find doesn't work on this set
+            this.rows.filter("tr:last").after(this.next_button);
+        }
+    };
+
+    Group.prototype.loadNext = function() {
+        var $hrow = this.header;
+        var page = $hrow.data('group-page') + 1;
+        var url = EPExtensions.setAttrToUrl(this.load_url, 'page', page);
+        var self = this;
+
+        if (page <= this.pages) {
+            $.get(url, function(data, textStatus, request) {
+                self.next_button.before(data);
+
+                self.loader.initInlineEdit();
+                $hrow.data('group-page', page);
+                if (self.pages == page) {
+                    self.next_button.remove();
+                }
+            });
+        }
+    };
+
+    Group.prototype.createNextButton = function() {
+        this.next_link = $('<a>', {href: this.load_url}).text(this.loader.texts['next']).append($("<i>", {"class": "icon-arrow"}));
+        this.next_button = $('<tr/>', {'class': 'easy-next-button'}).html($('<td>', {colspan: this.loader.options.next_button_cols, "class": "infinite-scroll-load-next-page-trigger-container"}).html(this.next_link));
+
+        var self = this;
+
+        this.next_link.click(function(evt) {
+            evt.preventDefault();
+            self.loadNext();
+        });
+    }
+
+})(jQuery);

data/app/controllers/easy_settings_controller.rb

@@ -0,0 +1,53 @@
+# edit and update actions are for a plugin settings
+# it uses a presenter, wich prefixes the settings name by a plugin id automatically
+class EasySettingsController < ApplicationController
+
+  before_filter :find_optional_project
+  before_filter :prepare_presenter
+  before_filter :find_plugin, only: [:edit, :update]
+
+  def new
+  end
+
+  def create
+    if @easy_settings.save
+      redirect_to :back
+    else
+      render :new
+    end
+  end
+
+  def edit
+    @settings = Setting.send "plugin_#{@plugin.id}"
+  end
+
+  def update
+    Setting.send "plugin_#{@plugin.id}=", params[:settings] if params[:settings]
+    if @easy_settings.save
+      flash[:notice] = l(:notice_successful_update)
+      redirect_to redmine_extensions_engine.edit_easy_setting_path(@easy_settings)
+    else
+      render :edit
+    end
+  end
+
+  private
+    def find_optional_project
+      @project = Project.find(params[:project_id]) unless params[:project_id].blank?
+    end
+
+    def prepare_presenter
+      @easy_settings = RedmineExtensions::EasySettingsPresenter.new(params[:easy_setting], @project)
+    end
+
+    def find_plugin
+      @plugin = Redmine::Plugin.find(params[:id])
+
+      return render_404 unless @plugin.settings.is_a?(Hash)
+
+      @easy_settings.plugin = @plugin
+
+    rescue Redmine::PluginNotFound
+      render_404
+    end
+end

data/app/helpers/redmine_extensions/application_helper.rb

@@ -1,4 +1,49 @@
 module RedmineExtensions
   module ApplicationHelper
+    include RenderingHelper
+
+    # -------= Hack methods =------
+
+    def plugin_settings_path(plugin, *attrs)
+      if plugin.settings[:only_easy] || plugin.settings[:easy_settings]
+        redmine_extensions_engine.edit_easy_setting_path(plugin, *attrs)
+      else
+        super
+      end
+    end
+
+    # -------= Rendering and presenting methods =-------
+
+    def present(model, options={}, &block)
+      if model.is_a?(RedmineExtensions::BasePresenter)
+        presenter = model.update_options(options.merge(view_context: self))
+      else
+        presenter = RedmineExtensions::BasePresenter.present(model, self, options)
+      end
+      if block_given?
+        yield presenter
+      else
+        presenter
+      end
+    end
+
+    # --- COMMON RENDERING ----
+
+    # hide elements for issues and users
+    def detect_hide_elements(uniq_id, user = nil, default = true)
+      return ''.html_safe if uniq_id.blank?
+      return 'style="display:none"'.html_safe if !toggle_button_expanded?(uniq_id, user, default)
+    end
+
+    def url_to_entity(entity, options={})
+      m = "url_to_#{entity.class.name.underscore}".to_sym
+      if respond_to?(m)
+        send(m, entity, options)
+      else
+        nil
+      end
+    end
+
+
   end
 end

data/app/helpers/redmine_extensions/rendering_helper.rb

@@ -0,0 +1,24 @@
+module RedmineExtensions
+  module RenderingHelper
+
+    def render_with_fallback(*attrs)
+      raise 'Missing an options argument' unless attrs.last.is_a?(Hash)
+      options = attrs.last
+      raise 'Missing an fallback prefixes' unless options[:prefixes]
+      partial = options[:partial] || attrs.first
+      prefixes = options.delete(:prefixes)
+
+      prefixes = prefixes.model if prefixes.is_a?(BasePresenter)
+      prefixes = prefixes.hiearchy.map{|klass| klass.underscore.pluralize } if prefixes.is_a?(ActiveRecord::Base)
+
+      prefixes.each do |prefix|
+        if lookup_context.template_exists?(partial, prefix, true)
+          partial.prepend("#{prefix}/")
+          return render(*attrs)
+        end
+      end
+      partial.prepend("#{prefixes.last}/")
+      render(*attrs)
+    end
+  end
+end